Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

next
ts 157 lines 5.17 KB
Raw
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 });