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
| 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 | ); |