@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, 04:45 UTC

next
ts 340 lines 11.6 KB
Raw
1 import type { ToolRetrieveResponse } from '@composio/client/resources/tools';
2 import { Effect, Layer, String } from 'effect';
3 import type {
4 ToolkitVersionOverrides,
5 ToolkitVersionSpec,
6 } from 'src/effects/toolkit-version-overrides';
7 import type { ToolkitDetailed, Toolkits } from 'src/models/toolkits';
8 import type { Tool, Tools } from 'src/models/tools';
9 import type { TriggerTypes, TriggerTypesAsEnums } from 'src/models/trigger-types';
10 import {
11 ComposioToolkitsRepository,
12 type ComposioToolkitsRepositoryShape,
13 type ToolkitProjectScope,
14 } from 'src/services/composio-clients';
15 import {
16 InvalidToolkitsError,
17 InvalidToolkitVersionsError,
18 type InvalidVersionDetail,
19 } from 'src/services/toolkit-version-validation';
20 import { makeToolkitsRepositoryStub } from '../services/toolkits-repository-stub';
21 import type { ConnectedAccountRepositoryMethod } from './connected-accounts';
22 import { notFoundError } from './not-found';
23 import { DEFAULT_PAGE_LIMIT } from './page';
24
25 /**
26 * The toolkit, tool, and trigger-type catalogs a test repository serves.
27 */
28 export interface ToolkitsTestData {
29 toolkits?: Toolkits;
30 /**
31 * Custom toolkits registered in the test project. Kept apart from
32 * `toolkits`, the Composio-managed catalog, as the API keeps them apart.
33 */
34 projectToolkits?: Toolkits;
35 /**
36 * The project `projectToolkits` belong to. When set, a project-toolkit
37 * lookup for any other scope, or for none, finds nothing, as the API
38 * would answer for another project.
39 */
40 projectToolkitsScope?: ToolkitProjectScope;
41 /**
42 * Called with the scope of every project-toolkit lookup.
43 */
44 onGetProjectToolkits?: (scope: ToolkitProjectScope | undefined) => void;
45 detailedToolkits?: ToolkitDetailed[];
46 tools?: Tools;
47 triggerTypesAsEnums?: TriggerTypesAsEnums;
48 triggerTypes?: TriggerTypes;
49 }
50
51 /**
52 * `ToolkitsTestData` with every catalog the test left out set to empty.
53 */
54 export const resolveToolkitsTestData = (data?: ToolkitsTestData) => {
55 const defaults = {
56 toolkits: [] as Toolkits,
57 projectToolkits: [] as Toolkits,
58 detailedToolkits: [] as ToolkitDetailed[],
59 tools: [] as Tools,
60 triggerTypesAsEnums: [] as TriggerTypesAsEnums,
61 triggerTypes: [] as TriggerTypes,
62 } satisfies ToolkitsTestData;
63 return {
64 ...defaults,
65 ...(data ?? {}),
66 detailedToolkits: data?.detailedToolkits ?? defaults.detailedToolkits,
67 };
68 };
69
70 export type ResolvedToolkitsTestData = ReturnType<typeof resolveToolkitsTestData>;
71
72 /**
73 * The repository methods other families serve: auth configs and connected accounts
74 * (`connected-accounts.ts`), and trigger instances.
75 */
76 type NonCatalogMethod =
77 | ConnectedAccountRepositoryMethod
78 | 'listActiveTriggers'
79 | 'createTrigger'
80 | 'enableTrigger'
81 | 'disableTrigger';
82
83 export type ToolkitCatalogMethods = Omit<ComposioToolkitsRepositoryShape, NonCatalogMethod>;
84
85 const toClientTool = (tool: Tool): ToolRetrieveResponse => {
86 // Derive toolkit slug from tool slug prefix (e.g. GMAIL_SEND_EMAIL -> gmail)
87 const parts = tool.slug.split('_');
88 const toolkitSlug = parts.length > 1 ? parts[0]!.toLowerCase() : '';
89 return {
90 ...tool,
91 available_versions: [...tool.available_versions],
92 tags: [...tool.tags],
93 no_auth: false,
94 version: 'latest',
95 scopes: [],
96 scope_requirements: null,
97 is_deprecated: false,
98 deprecated: {
99 displayName: tool.name,
100 version: 'latest',
101 available_versions: [...tool.available_versions],
102 is_deprecated: false,
103 toolkit: { logo: '' },
104 },
105 toolkit: { name: toolkitSlug, slug: toolkitSlug, logo: '' },
106 };
107 };
108
109 /**
110 * The repository's catalog methods, answering from `toolkitsData` the way the API would.
111 */
112 export const toolkitCatalogMethods = (
113 toolkitsData: ResolvedToolkitsTestData
114 ): ToolkitCatalogMethods => ({
115 getToolkits: () => Effect.succeed(toolkitsData.toolkits),
116 getProjectToolkits: scope =>
117 Effect.sync(() => {
118 toolkitsData.onGetProjectToolkits?.(scope);
119 const owner = toolkitsData.projectToolkitsScope;
120 const inScope =
121 owner === undefined ||
122 (scope?.orgId === owner.orgId && scope.projectId === owner.projectId);
123 return inScope ? toolkitsData.projectToolkits : [];
124 }),
125 getToolkitsBySlugs: (slugs: ReadonlyArray<string>) => {
126 const normalizedSlugs = new Set(slugs.map(s => String.toLowerCase(s)));
127 const found = toolkitsData.toolkits.filter(t =>
128 normalizedSlugs.has(String.toLowerCase(t.slug))
129 );
130 if (found.length !== slugs.length) {
131 const foundSlugs = new Set(found.map(t => String.toLowerCase(t.slug)));
132 const notFound = slugs.filter(s => !foundSlugs.has(String.toLowerCase(s)));
133 return Effect.fail(
134 new InvalidToolkitsError({
135 invalidToolkits: [...notFound],
136 availableToolkits: toolkitsData.toolkits.map(t => t.slug),
137 })
138 );
139 }
140 return Effect.succeed(found);
141 },
142 getMetrics: () => Effect.succeed({ byteSize: 0, requests: 0 }),
143 getToolsAsEnums: () => Effect.succeed(toolkitsData.tools.map(tool => tool.slug)),
144 getTriggerTypesAsEnums: () => Effect.succeed(toolkitsData.triggerTypesAsEnums),
145 getTriggerTypes: (toolkitSlugs?: ReadonlyArray<string>) => {
146 let triggers = toolkitsData.triggerTypes;
147 if (toolkitSlugs && toolkitSlugs.length > 0) {
148 const prefixes = toolkitSlugs.map(s => `${s.toUpperCase()}_`);
149 triggers = triggers.filter(t => prefixes.some(p => t.slug.toUpperCase().startsWith(p)));
150 }
151 return Effect.succeed(triggers);
152 },
153 getTriggerTypeDetailed: (slug: string) => {
154 const found = toolkitsData.triggerTypes.find(
155 trigger => trigger.slug.toUpperCase() === slug.toUpperCase()
156 );
157 if (!found) {
158 return Effect.fail(notFoundError(`Trigger type "${slug}" not found`));
159 }
160 return Effect.succeed(found);
161 },
162 getTools: (toolkitSlugs?: ReadonlyArray<string>) => {
163 let tools = toolkitsData.tools;
164 if (toolkitSlugs && toolkitSlugs.length > 0) {
165 const prefixes = toolkitSlugs.map(s => `${s.toUpperCase()}_`);
166 tools = tools.filter(t => prefixes.some(p => t.slug.toUpperCase().startsWith(p)));
167 }
168 return Effect.succeed(tools);
169 },
170 validateToolkits: (toolkitSlugs: ReadonlyArray<string>) => {
171 const normalizedInputSlugs = toolkitSlugs.map(slug => String.toLowerCase(slug));
172 const availableSlugs = toolkitsData.toolkits.map(toolkit => String.toLowerCase(toolkit.slug));
173 const invalidSlugs = normalizedInputSlugs.filter(slug => !availableSlugs.includes(slug));
174
175 if (invalidSlugs.length > 0) {
176 return Effect.fail(
177 new InvalidToolkitsError({
178 invalidToolkits: invalidSlugs,
179 availableToolkits: availableSlugs,
180 })
181 );
182 }
183
184 return Effect.succeed(normalizedInputSlugs);
185 },
186 filterToolkitsBySlugs: (toolkits, toolkitSlugs) => {
187 const normalizedSlugs = new Set(toolkitSlugs.map(slug => String.toLowerCase(slug)));
188 return toolkits.filter(toolkit => normalizedSlugs.has(String.toLowerCase(toolkit.slug)));
189 },
190 getToolsByVersionSpecs: (specs: ReadonlyArray<ToolkitVersionSpec>) => {
191 // Filter tools based on toolkit slugs from specs
192 const toolkitSlugs = specs.map(s => s.toolkitSlug.toUpperCase());
193 const prefixes = toolkitSlugs.map(s => `${s}_`);
194 const tools = toolkitsData.tools.filter(t =>
195 prefixes.some(p => t.slug.toUpperCase().startsWith(p))
196 );
197 return Effect.succeed(tools);
198 },
199 validateToolkitVersions: (
200 overrides: ToolkitVersionOverrides,
201 relevantToolkits?: ReadonlyArray<string>
202 ) => {
203 // Mock implementation that validates against test fixture
204 const invalidVersions: InvalidVersionDetail[] = [];
205 const warnings: string[] = [];
206
207 for (const [toolkit, version] of overrides) {
208 // Check if toolkit should be validated
209 if (relevantToolkits && !relevantToolkits.map(s => s.toLowerCase()).includes(toolkit)) {
210 warnings.push(`Version override for "${toolkit}" will be ignored`);
211 continue;
212 }
213
214 // Check if toolkit exists in the fixture
215 const toolkitExists = toolkitsData.toolkits.some(t => String.toLowerCase(t.slug) === toolkit);
216
217 if (!toolkitExists) {
218 return Effect.fail(
219 new InvalidToolkitsError({
220 invalidToolkits: [toolkit],
221 availableToolkits: toolkitsData.toolkits.map(t => t.slug),
222 })
223 );
224 }
225
226 // Mock: only accept 'latest' or versions matching pattern YYYYMMDD_NN
227 const validPattern = /^\d{8}_\d{2}$/;
228 if (version !== 'latest' && !validPattern.test(version)) {
229 invalidVersions.push({
230 toolkit,
231 requestedVersion: version,
232 availableVersions: ['20250901_00', '20250815_00', '20250710_00'],
233 });
234 }
235 }
236
237 if (invalidVersions.length > 0) {
238 return Effect.fail(new InvalidToolkitVersionsError({ invalidVersions }));
239 }
240
241 return Effect.succeed({
242 validatedOverrides: overrides,
243 warnings: warnings as ReadonlyArray<string>,
244 });
245 },
246 searchToolkits: (params: {
247 search?: string;
248 category?: string;
249 limit?: number;
250 cursor?: string;
251 }) => {
252 let results = [...toolkitsData.toolkits];
253
254 if (params.search) {
255 const q = params.search.toLowerCase();
256 results = results.filter(
257 t =>
258 t.name.toLowerCase().includes(q) ||
259 t.slug.toLowerCase().includes(q) ||
260 t.meta.description.toLowerCase().includes(q)
261 );
262 }
263
264 const limit = params.limit ?? DEFAULT_PAGE_LIMIT;
265 const items = results.slice(0, limit);
266 return Effect.succeed({
267 items,
268 total_items: results.length,
269 total_pages: Math.ceil(results.length / limit),
270 next_cursor: null,
271 });
272 },
273 searchTools: (params: {
274 search?: string;
275 toolkit_slug?: string;
276 tags?: string;
277 limit?: number;
278 cursor?: string;
279 }) => {
280 let results = [...toolkitsData.tools];
281
282 if (params.toolkit_slug) {
283 const slugs = params.toolkit_slug.split(',').map(s => s.trim().toUpperCase() + '_');
284 results = results.filter(t => slugs.some(p => t.slug.toUpperCase().startsWith(p)));
285 }
286
287 if (params.search) {
288 const q = params.search.toLowerCase();
289 results = results.filter(
290 t =>
291 t.name.toLowerCase().includes(q) ||
292 t.slug.toLowerCase().includes(q) ||
293 t.description.toLowerCase().includes(q)
294 );
295 }
296
297 if (params.tags) {
298 const tagList = params.tags.split(',').map(t => t.trim().toLowerCase());
299 results = results.filter(t =>
300 tagList.some(tag => t.tags.map(tt => tt.toLowerCase()).includes(tag))
301 );
302 }
303
304 const limit = params.limit ?? DEFAULT_PAGE_LIMIT;
305 const items = results.slice(0, limit).map(toClientTool);
306 return Effect.succeed({
307 items,
308 total_items: results.length,
309 total_pages: Math.ceil(results.length / limit),
310 current_page: 1,
311 next_cursor: null,
312 });
313 },
314 getToolDetailed: (slug: string) => {
315 const found = toolkitsData.tools.find(t => t.slug.toUpperCase() === slug.toUpperCase());
316 if (!found) {
317 return Effect.fail(notFoundError(`Tool "${slug}" not found`));
318 }
319 return Effect.succeed(toClientTool(found));
320 },
321 getToolkitDetailed: (slug: string) => {
322 const found = toolkitsData.detailedToolkits.find(
323 t => t.slug.toLowerCase() === slug.toLowerCase()
324 );
325 if (!found) {
326 return Effect.fail(notFoundError(`Toolkit "${slug}" not found`));
327 }
328 return Effect.succeed(found);
329 },
330 });
331
332 /**
333 * A `ComposioToolkitsRepository` that serves only the catalogs, for a test that needs nothing
334 * else from the full `TestLive` layer. Any other repository method dies.
335 */
336 export const ToolkitsTest = (data?: ToolkitsTestData) =>
337 Layer.succeed(
338 ComposioToolkitsRepository,
339 makeToolkitsRepositoryStub(toolkitCatalogMethods(resolveToolkitsTestData(data)))
340 );