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 199 lines 7.43 KB
Raw
1 /**
2 * The `composio generate py` command can be configured as follows:
3 * - `--output-dir`: Output directory for the generated Python type stubs.
4 * - `--toolkits`: Filter output to only include the specified toolkits. Can be specified multiple times (e.g., --toolkits gmail --toolkits slack)
5 *
6 * Environment variables:
7 * - `COMPOSIO_TOOLKIT_VERSION_<TOOLKIT>`: Override a toolkit version (e.g., COMPOSIO_TOOLKIT_VERSION_GMAIL=20250901_00).
8 * Use "latest" or unset to use the latest version.
9 */
10
11 import { Array, Effect, Option, pipe, String } from 'effect';
12 import * as FileSystem from 'effect/FileSystem';
13 import * as Path from 'effect/Path';
14 import { commandInputError } from 'src/commands/errors';
15 import { ComposioToolkitsRepository } from 'src/services/composio-clients';
16 import { logMetrics } from 'src/effects/log-metrics';
17 import { NodeProcess } from 'src/services/node-process';
18 import { pyFindComposioCoreGenerated } from 'src/effects/find-composio-core-generated';
19 import { generationOutcome, loadGenerationRuntime } from 'src/effects/generation-runtime';
20 import {
21 getToolkitVersionOverrides,
22 type ToolkitVersionOverrides,
23 } from 'src/effects/toolkit-version-overrides';
24 import { validateToolkitVersionOverrides } from 'src/effects/validate-toolkit-versions';
25 import { TerminalUI } from 'src/services/terminal-ui';
26 import { PythonGenerationWriteError } from './generate.py.errors';
27
28 export type GeneratePyParams = {
29 readonly outputDir: Option.Option<string>;
30 readonly toolkits: ReadonlyArray<string>;
31 };
32
33 const invalidGenerateValue = commandInputError('generate py');
34
35 export const runGeneratePy = (params: GeneratePyParams) =>
36 Effect.gen(function* () {
37 const ui = yield* TerminalUI;
38 const process = yield* NodeProcess;
39 const cwd = process.cwd;
40 const fs = yield* FileSystem.FileSystem;
41 const path = yield* Path.Path;
42 const client = yield* ComposioToolkitsRepository;
43
44 yield* ui.intro('composio generate py');
45
46 // Determine the actual output directory
47 const outputDir = yield* params.outputDir.pipe(
48 Option.match({
49 // If no output directory is specified, use the default
50 onNone: () => pyFindComposioCoreGenerated(cwd),
51
52 // If an output directory is specified, validate and create it
53 onSome: outputDir => {
54 const normalizedPath = path.normalize(outputDir);
55 if (normalizedPath.includes('node_modules')) {
56 return Effect.fail(
57 invalidGenerateValue(
58 'Output directory cannot be inside node_modules. Please specify a different directory.',
59 '--output-dir'
60 )
61 );
62 }
63 return Effect.succeed(outputDir);
64 },
65 })
66 );
67
68 yield* ui.log.step(`Writing type stubs to ${outputDir}`);
69 yield* fs.makeDirectory(outputDir, { recursive: true });
70
71 // Read toolkit version overrides from environment variables
72 const versionOverrides = yield* getToolkitVersionOverrides;
73
74 // Validate toolkit slugs if specified
75 const hasToolkitsFilter = Array.isReadonlyArrayNonEmpty(params.toolkits);
76 const toolkitSlugsFilter = hasToolkitsFilter ? params.toolkits.map(s => s.toLowerCase()) : null;
77
78 // Validate toolkit version overrides before fetching data
79 const { validatedOverrides } = yield* validateToolkitVersionOverrides({
80 versionOverrides,
81 toolkitSlugsFilter,
82 client,
83 });
84
85 // Fetch, generate, and write with a spinner that auto-cleans up on error
86 yield* ui.useMakeSpinner('Fetching data from Composio API...', spinner =>
87 Effect.gen(function* () {
88 // Validate toolkit slugs if specified (separate from version validation)
89 const validatedToolkitSlugs = hasToolkitsFilter
90 ? yield* client
91 .validateToolkits(params.toolkits)
92 .pipe(
93 Effect.catchTag('services/InvalidToolkitsError', error =>
94 Effect.fail(
95 invalidGenerateValue(
96 `Invalid toolkit(s): ${error.invalidToolkits.join(', ')}. ` +
97 `Available toolkits: ${error.availableToolkits.slice(0, 10).join(', ')}${error.availableToolkits.length > 10 ? '...' : ''}`,
98 '--toolkits'
99 )
100 )
101 )
102 )
103 : [];
104
105 const [allToolkits, tools, triggerTypes] = yield* Effect.all(
106 [
107 Effect.logDebug('Fetching toolkits...').pipe(
108 Effect.flatMap(() => client.getToolkits())
109 ),
110 Effect.logDebug('Fetching tools...').pipe(
111 Effect.flatMap(() => client.getToolsAsEnums())
112 ),
113 Effect.logDebug('Fetching trigger types...').pipe(
114 Effect.flatMap(() => client.getTriggerTypes())
115 ),
116 ],
117 { concurrency: 'unbounded' }
118 );
119
120 // Filter toolkits if --toolkits was specified
121 const toolkits = hasToolkitsFilter
122 ? client.filterToolkitsBySlugs(allToolkits, validatedToolkitSlugs)
123 : allToolkits;
124
125 if (hasToolkitsFilter) {
126 yield* spinner.message(
127 `Found ${toolkits.length} toolkit(s): ${toolkits.map(t => t.slug).join(', ')}`
128 );
129 }
130
131 // Build version map for toolkits being generated (using validated overrides)
132 const versionMap: ToolkitVersionOverrides = new Map();
133 for (const toolkit of toolkits) {
134 const normalizedSlug = String.toLowerCase(toolkit.slug);
135 const version = validatedOverrides.get(normalizedSlug);
136 if (version && version !== 'latest') {
137 versionMap.set(normalizedSlug, version);
138 }
139 }
140
141 const typeableTools = { withTypes: false as const, tools };
142
143 yield* spinner.message('Generating Python type stubs...');
144 // The generation pipeline lives in the `generation-runtime` companion
145 // module, loaded from disk here so no other command pays for it at startup.
146 const generation = yield* loadGenerationRuntime;
147 const index = generation.createToolkitIndex({
148 toolkits,
149 typeableTools,
150 triggerTypes,
151 versionMap,
152 });
153
154 // Generate Python sources
155 const sources = yield* generationOutcome(() =>
156 generation.generatePythonSourceFiles({ banner: generation.BANNER, outputDir }, index)
157 );
158
159 yield* spinner.message('Writing files to disk...');
160
161 // Write all generated files
162 yield* pipe(
163 Effect.all(
164 sources.map(([filePath, content]) =>
165 fs.writeFileString(filePath, content).pipe(
166 Effect.mapError(
167 cause =>
168 new PythonGenerationWriteError({
169 cause,
170 filePath,
171 message: `Failed to write file ${filePath}`,
172 })
173 )
174 )
175 ),
176 { concurrency: 1 }
177 )
178 );
179
180 yield* spinner.stop('Type stubs generated successfully');
181 })
182 );
183
184 yield* Option.isNone(params.outputDir)
185 ? ui.note(
186 'from composio.generated.<toolkit_name> import <TOOLKIT_NAME>',
187 'Import your generated types'
188 )
189 : ui.log.info(`Generated files are available at: ${outputDir}`);
190
191 // Log API metrics
192 const metrics = yield* client.getMetrics();
193 yield* logMetrics(metrics);
194
195 yield* ui.outro('Done');
196 yield* ui.output(outputDir);
197
198 return outputDir;
199 });