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 { Data, Effect, String } from 'effect'; |
| 2 | import type { Toolkit } from 'src/models/toolkits'; |
| 3 | import type { ToolkitVersionOverrides } from 'src/effects/toolkit-version-overrides'; |
| 4 | import type { ClientError } from './composio-errors'; |
| 5 | import { MAX_CONCURRENT_REQUESTS_PER_ENDPOINT } from './composio-request'; |
| 6 | |
| 7 | /** |
| 8 | * Error thrown when one or more toolkit slugs are invalid. |
| 9 | */ |
| 10 | export class InvalidToolkitsError extends Data.TaggedError('services/InvalidToolkitsError')<{ |
| 11 | readonly invalidToolkits: ReadonlyArray<string>; |
| 12 | readonly availableToolkits: ReadonlyArray<string>; |
| 13 | }> {} |
| 14 | |
| 15 | /** |
| 16 | * Details about a single invalid version override. |
| 17 | */ |
| 18 | export interface InvalidVersionDetail { |
| 19 | readonly toolkit: string; |
| 20 | readonly requestedVersion: string; |
| 21 | readonly availableVersions: ReadonlyArray<string>; |
| 22 | } |
| 23 | |
| 24 | /** |
| 25 | * Error thrown when one or more toolkit version overrides are invalid. |
| 26 | */ |
| 27 | export class InvalidToolkitVersionsError extends Data.TaggedError( |
| 28 | 'services/InvalidToolkitVersionsError' |
| 29 | )<{ |
| 30 | readonly invalidVersions: ReadonlyArray<InvalidVersionDetail>; |
| 31 | }> {} |
| 32 | |
| 33 | /** |
| 34 | * Converts a 404 from a toolkit lookup into `InvalidToolkitsError` naming |
| 35 | * that slug; every other failure propagates unchanged. |
| 36 | */ |
| 37 | export const invalidToolkitOn404 = <A>(slug: string, toolkit: Effect.Effect<A, ClientError>) => |
| 38 | Effect.catchTag(toolkit, '@composio/client/NotFoundError', () => |
| 39 | Effect.fail( |
| 40 | new InvalidToolkitsError({ |
| 41 | invalidToolkits: [slug], |
| 42 | availableToolkits: [], |
| 43 | }) |
| 44 | ) |
| 45 | ); |
| 46 | |
| 47 | export const validateToolkitVersionsImpl = ( |
| 48 | retrieveToolkit: (slug: string) => Effect.Effect<Toolkit, ClientError, never>, |
| 49 | overrides: ToolkitVersionOverrides, |
| 50 | relevantToolkits?: ReadonlyArray<string> |
| 51 | ): Effect.Effect< |
| 52 | { |
| 53 | validatedOverrides: ToolkitVersionOverrides; |
| 54 | warnings: ReadonlyArray<string>; |
| 55 | }, |
| 56 | InvalidToolkitVersionsError | InvalidToolkitsError | ClientError |
| 57 | > => |
| 58 | Effect.gen(function* () { |
| 59 | const determineOverridesToValidate = ( |
| 60 | overrides: ToolkitVersionOverrides, |
| 61 | relevantToolkits?: ReadonlyArray<string> |
| 62 | ): { |
| 63 | overridesToValidate: Array<[toolkit: string, requestedVersion: string]>; |
| 64 | warnings: Array<string>; |
| 65 | } => { |
| 66 | const warnings: string[] = []; |
| 67 | const overridesToValidate: Array<[toolkit: string, requestedVersion: string]> = []; |
| 68 | |
| 69 | if (relevantToolkits) { |
| 70 | const relevantSet = new Set(relevantToolkits.map(s => String.toLowerCase(s))); |
| 71 | |
| 72 | for (const [toolkit, version] of overrides) { |
| 73 | if (relevantSet.has(toolkit)) { |
| 74 | overridesToValidate.push([toolkit, version]); |
| 75 | } else { |
| 76 | warnings.push( |
| 77 | `Version override for "${toolkit}" will be ignored (toolkit not in --toolkits filter)` |
| 78 | ); |
| 79 | } |
| 80 | } |
| 81 | } else { |
| 82 | overridesToValidate.push(...overrides.entries()); |
| 83 | } |
| 84 | |
| 85 | return { overridesToValidate, warnings }; |
| 86 | }; |
| 87 | |
| 88 | const fetchToolkitVersionValidationResults = ( |
| 89 | overridesToValidate: ReadonlyArray<[toolkit: string, requestedVersion: string]> |
| 90 | ): Effect.Effect< |
| 91 | ReadonlyArray<{ |
| 92 | toolkit: string; |
| 93 | requestedVersion: string; |
| 94 | availableVersions: ReadonlyArray<string>; |
| 95 | isValid: boolean; |
| 96 | }>, |
| 97 | InvalidToolkitsError | ClientError |
| 98 | > => |
| 99 | Effect.all( |
| 100 | overridesToValidate.map(([toolkit, requestedVersion]) => |
| 101 | invalidToolkitOn404( |
| 102 | toolkit, |
| 103 | retrieveToolkit(toolkit).pipe( |
| 104 | Effect.map(toolkitData => ({ |
| 105 | toolkit, |
| 106 | requestedVersion, |
| 107 | availableVersions: toolkitData.meta.available_versions, |
| 108 | isValid: toolkitData.meta.available_versions.includes(requestedVersion), |
| 109 | })) |
| 110 | ) |
| 111 | ) |
| 112 | ), |
| 113 | { concurrency: MAX_CONCURRENT_REQUESTS_PER_ENDPOINT } |
| 114 | ); |
| 115 | |
| 116 | const collectInvalidVersions = ( |
| 117 | validationResults: ReadonlyArray<{ |
| 118 | toolkit: string; |
| 119 | requestedVersion: string; |
| 120 | availableVersions: ReadonlyArray<string>; |
| 121 | isValid: boolean; |
| 122 | }> |
| 123 | ): ReadonlyArray<InvalidVersionDetail> => |
| 124 | validationResults |
| 125 | .filter(result => !result.isValid) |
| 126 | .map(result => ({ |
| 127 | toolkit: result.toolkit, |
| 128 | requestedVersion: result.requestedVersion, |
| 129 | availableVersions: result.availableVersions, |
| 130 | })); |
| 131 | |
| 132 | if (overrides.size === 0) { |
| 133 | return { validatedOverrides: overrides, warnings: [] as ReadonlyArray<string> }; |
| 134 | } |
| 135 | |
| 136 | const { overridesToValidate, warnings } = determineOverridesToValidate( |
| 137 | overrides, |
| 138 | relevantToolkits |
| 139 | ); |
| 140 | |
| 141 | if (overridesToValidate.length === 0) { |
| 142 | return { |
| 143 | validatedOverrides: new Map() as ToolkitVersionOverrides, |
| 144 | warnings: warnings as ReadonlyArray<string>, |
| 145 | }; |
| 146 | } |
| 147 | |
| 148 | const validationResults = yield* fetchToolkitVersionValidationResults(overridesToValidate); |
| 149 | const invalidVersions = collectInvalidVersions(validationResults); |
| 150 | |
| 151 | if (invalidVersions.length > 0) { |
| 152 | return yield* Effect.fail(new InvalidToolkitVersionsError({ invalidVersions })); |
| 153 | } |
| 154 | |
| 155 | const validatedOverrides = new Map(overridesToValidate) as ToolkitVersionOverrides; |
| 156 | return { validatedOverrides, warnings: warnings as ReadonlyArray<string> }; |
| 157 | }); |