Skip to content

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

feat(ts/cli): optimize client requests; bandwidth usage of "composio ts generate--type-tools --toolkits entelligence" went from 112MB to 6.21 KB

jkomyno0a56414beb6a
diff --git a/ts/packages/cli/package.json b/ts/packages/cli/package.json
index 43ef78a00..420f24047 100644
--- a/ts/packages/cli/package.json
+++ b/ts/packages/cli/package.json
@@ -26,6 +26,7 @@
"cli": "bun run src/bin.ts",
"build:bin": "bun run ./scripts/build-binary.ts",
"install:bin": "bun run ./scripts/install-binary.ts ./dist/composio",
+ "table:metrics": "bun run ./scripts/optimize-metrics-table.ts",
"mock": "bun run ./scripts/copy-mocks-from-cache.ts",
"prebuild": "pnpm run typecheck",
"build": "tsdown",
diff --git a/ts/packages/cli/scripts/optimize-metrics-table.ts b/ts/packages/cli/scripts/optimize-metrics-table.ts
new file mode 100644
index 000000000..b1feb04ab
--- /dev/null
+++ b/ts/packages/cli/scripts/optimize-metrics-table.ts
@@ -0,0 +1,86 @@
+#!/usr/bin/env bun
+
+/**
+ * Generate a Markdown table comparing API metrics before and after an optimization PR.
+ *
+ * Usage:
+ * pnpm run metrics
+ */
+
+interface Metric {
+ requests: number;
+ megabytes: number;
+}
+
+interface MetricRow {
+ name: string;
+ before: Metric;
+ after: Metric;
+}
+
+const data: MetricRow[] = [
+ {
+ name: 'Default',
+ before: { requests: 4, megabytes: 1.71 },
+ after: { requests: 3, megabytes: 1.7 },
+ },
+ {
+ name: '`--type-tools`',
+ before: { requests: 26, megabytes: 111.3 },
+ after: { requests: 24, megabytes: 110.62 },
+ },
+ {
+ name: '`--toolkits entelligence`',
+ before: { requests: 5, megabytes: 2.35 },
+ after: { requests: 3, megabytes: 718.68 / 1024 }, // Convert KB to MB
+ },
+ {
+ name: '`--type-tools` + `--toolkits entelligence`',
+ before: { requests: 27, megabytes: 111.94 },
+ after: { requests: 3, megabytes: 6.21 / 1024 }, // Convert KB to MB
+ },
+];
+
+function percentChange(before: number, after: number): string {
+ let change = ((after - before) / before) * 100;
+ // Cap at -99.9% unless it's truly 0
+ if (after > 0 && change < -99.9) {
+ change = -99.9;
+ }
+ const sign = change > 0 ? '+' : '';
+ return `${sign}${change.toFixed(1)}%`;
+}
+
+function formatMB(mb: number): string {
+ if (mb < 1) {
+ return `${(mb * 1024).toFixed(2)} KB`;
+ }
+ return `${mb.toFixed(2)} MB`;
+}
+
+function generateMarkdownTable(rows: MetricRow[]): string {
+ const lines: string[] = [];
+
+ lines.push('# Metrics Comparison: Before vs After Optimization');
+ lines.push('');
+ lines.push(
+ '| Case | Requests (Before) | Requests (After) | Requests Δ | Downloaded (Before) | Downloaded (After) | Downloaded Δ |'
+ );
+ lines.push(
+ '|------|-------------------|------------------|------------|---------------------|--------------------|--------------| '
+ );
+
+ for (const row of rows) {
+ const reqChange = percentChange(row.before.requests, row.after.requests);
+ const mbChange = percentChange(row.before.megabytes, row.after.megabytes);
+
+ lines.push(
+ `| ${row.name} | ${row.before.requests} | ${row.after.requests} | ${reqChange} | ${formatMB(row.before.megabytes)} | ${formatMB(row.after.megabytes)} | ${mbChange} |`
+ );
+ }
+
+ return lines.join('\n');
+}
+
+const table = generateMarkdownTable(data);
+console.log(table);
diff --git a/ts/packages/cli/src/commands/py/commands/py.generate.cmd.ts b/ts/packages/cli/src/commands/py/commands/py.generate.cmd.ts
index 8e777b8e4..6e6f2adb9 100644
--- a/ts/packages/cli/src/commands/py/commands/py.generate.cmd.ts
+++ b/ts/packages/cli/src/commands/py/commands/py.generate.cmd.ts
@@ -78,16 +78,12 @@ export function generatePythonTypeStubs({
)
: [];
- const triggerTypesAsEnums = yield* Effect.logDebug('Fetching trigger types...').pipe(
- Effect.flatMap(() => client.getTriggerTypesAsEnums())
- );
-
const [allToolkits, tools, triggerTypes] = yield* Effect.all(
[
Effect.logDebug('Fetching toolkits...').pipe(Effect.flatMap(() => client.getToolkits())),
Effect.logDebug('Fetching tools...').pipe(Effect.flatMap(() => client.getToolsAsEnums())),
- Effect.logDebug('Fetching trigger types payloads...').pipe(
- Effect.flatMap(() => client.getTriggerTypes(triggerTypesAsEnums.length))
+ Effect.logDebug('Fetching trigger types...').pipe(
+ Effect.flatMap(() => client.getTriggerTypes())
),
],
{ concurrency: 'unbounded' }
diff --git a/ts/packages/cli/src/commands/ts/commands/ts.generate.cmd.ts b/ts/packages/cli/src/commands/ts/commands/ts.generate.cmd.ts
index e8984ac04..76f8da880 100644
--- a/ts/packages/cli/src/commands/ts/commands/ts.generate.cmd.ts
+++ b/ts/packages/cli/src/commands/ts/commands/ts.generate.cmd.ts
@@ -29,6 +29,9 @@ import { generateTypeScriptSources } from 'src/generation/typescript/generate';
import { jsFindComposioCoreGenerated } from 'src/effects/find-composio-core-generated';
import { transpileTypeScriptSources } from 'src/generation/typescript/transpile';
import { BANNER } from 'src/generation/constants';
+import type { Toolkit } from 'src/models/toolkits';
+import type { TriggerType } from 'src/models/trigger-types';
+import type { Tool, ToolsAsEnums } from 'src/models/tools';
export const outputOpt = Options.optional(
Options.directory('output-dir', {
@@ -75,6 +78,140 @@ const _tsCmd$Generate = Command.make('generate', {
)
);
+/**
+ * Result type for fetching toolkit data
+ */
+type FetchResult = {
+ toolkits: ReadonlyArray<Toolkit>;
+ triggerTypes: ReadonlyArray<TriggerType>;
+ typeableTools:
+ | { withTypes: true; tools: ReadonlyArray<Tool> }
+ | { withTypes: false; tools: ToolsAsEnums };
+};
+
+/**
+ * Fetches data for specific toolkits when --toolkits filter is provided.
+ * Makes targeted API calls for only the requested toolkits.
+ */
+function fetchFilteredData(
+ client: ComposioToolkitsRepository,
+ slugs: ReadonlyArray<string>,
+ typeTools: boolean
+): Effect.Effect<FetchResult, Error, never> {
+ return Effect.gen(function* () {
+ yield* Console.log(`Fetching data for ${slugs.length} toolkit(s): ${slugs.join(', ')}...`);
+
+ const [filteredToolkits, filteredTriggerTypes, filteredTypeableTools] = yield* Effect.all(
+ [
+ // Fetch only the specified toolkits by slug
+ Effect.logDebug(`Fetching ${slugs.length} toolkit(s) by slug...`).pipe(
+ Effect.flatMap(() =>
+ client
+ .getToolkitsBySlugs(slugs)
+ .pipe(
+ Effect.catchTag('services/InvalidToolkitsError', error =>
+ Effect.fail(
+ new Error(
+ `Invalid toolkit(s): ${error.invalidToolkits.join(', ')}. Toolkit not found.`
+ )
+ )
+ )
+ )
+ )
+ ),
+ // Fetch only trigger types for the specified toolkits
+ Effect.logDebug(`Fetching trigger types for ${slugs.length} toolkit(s)...`).pipe(
+ Effect.flatMap(() => client.getTriggerTypes(slugs))
+ ),
+ // Fetch tools for the specified toolkits
+ Match.value(typeTools).pipe(
+ Match.when(true, withTypes =>
+ Effect.logDebug(`Fetching tools with schemas for ${slugs.length} toolkit(s)...`).pipe(
+ Effect.flatMap(() => client.getTools(slugs)),
+ Effect.map(tools => ({ withTypes, tools }))
+ )
+ ),
+ Match.when(false, withTypes =>
+ Effect.logDebug(`Fetching tool names for ${slugs.length} toolkit(s)...`).pipe(
+ Effect.flatMap(() => client.getToolsAsEnums()),
+ Effect.map(allTools => ({
+ withTypes,
+ // Filter tool enums by toolkit prefix
+ tools: allTools.filter(tool => {
+ const prefix = tool.split('_')[0]?.toLowerCase();
+ return slugs.some(s => s.toLowerCase() === prefix);
+ }),
+ }))
+ )
+ ),
+ Match.exhaustive
+ ),
+ ],
+ { concurrency: 'unbounded' }
+ );
+
+ yield* Console.log(
+ `Filtering to ${filteredToolkits.length} toolkit(s): ${filteredToolkits.map(t => t.slug).join(', ')}`
+ );
+
+ return {
+ toolkits: filteredToolkits,
+ triggerTypes: filteredTriggerTypes,
+ typeableTools: filteredTypeableTools,
+ };
+ });
+}
+
+/**
+ * Fetches all toolkit data when no --toolkits filter is provided.
+ * Fetches everything from the API.
+ */
+function fetchAllData(
+ client: ComposioToolkitsRepository,
+ typeTools: boolean
+): Effect.Effect<FetchResult, Error, never> {
+ return Effect.gen(function* () {
+ yield* Console.log('Fetching all toolkits, tools, and triggers from Composio API...');
+
+ // Fetch all data in parallel
+ // Note: getToolsAsEnums is only called when typeTools === false
+ const [allToolkits, allTriggerTypes, allTypeableTools] = yield* Effect.all(
+ [
+ Effect.logDebug('Fetching all toolkits...').pipe(
+ Effect.flatMap(() => client.getToolkits())
+ ),
+ Effect.logDebug('Fetching all trigger types...').pipe(
+ Effect.flatMap(() => client.getTriggerTypes())
+ ),
+ Match.value(typeTools).pipe(
+ Match.when(true, withTypes =>
+ Effect.logDebug('Fetching all tools with schemas...').pipe(
+ Effect.flatMap(() => client.getTools()),
+ Effect.map(tools => ({ withTypes, tools }))
+ )
+ ),
+ Match.when(false, withTypes =>
+ Effect.logDebug('Fetching all tool names...').pipe(
+ Effect.flatMap(() => client.getToolsAsEnums()),
+ Effect.map(tools => ({ withTypes, tools }))
+ )
+ ),
+ Match.exhaustive
+ ),
+ ],
+ { concurrency: 'unbounded' }
+ );
+
+ yield* Console.log(`Found ${allToolkits.length} toolkit(s)`);
+
+ return {
+ toolkits: allToolkits,
+ triggerTypes: allTriggerTypes,
+ typeableTools: allTypeableTools,
+ };
+ });
+}
+
/**
* Validates that the output directory is not inside node_modules
*/
@@ -136,73 +273,15 @@ export function generateTypescriptTypeStubs({
yield* Effect.log(`Writing type stubs to ${outputDir}...`);
yield* fs.makeDirectory(outputDir, { recursive: true });
- // Fetch data from Composio API
- yield* Console.log('Fetching latest data from Composio API. This may take a while...');
-
- // Validate toolkit slugs if specified
- const hasToolkitsFilter = Array.isNonEmptyArray(toolkitsOpt);
- const validatedToolkitSlugs = hasToolkitsFilter
- ? yield* client
- .validateToolkits(toolkitsOpt)
- .pipe(
- Effect.catchTag('services/InvalidToolkitsError', error =>
- Effect.fail(
- new Error(
- `Invalid toolkit(s): ${error.invalidToolkits.join(', ')}. ` +
- `Available toolkits: ${error.availableToolkits.slice(0, 10).join(', ')}${error.availableToolkits.length > 10 ? '...' : ''}`
- )
- )
- )
- )
- : [];
+ // Normalize toolkit slugs if specified (lowercase for API filtering)
+ const toolkitSlugsFilter = Array.isNonEmptyArray(toolkitsOpt)
+ ? toolkitsOpt.map(s => s.toLowerCase())
+ : null;
- const [triggerTypesAsEnums, toolsAsEnums] = yield* Effect.all([
- Effect.logDebug('Fetching trigger types...').pipe(
- Effect.flatMap(() => client.getTriggerTypesAsEnums())
- ),
- Effect.logDebug('Fetching tools...').pipe(Effect.flatMap(() => client.getToolsAsEnums())),
- ]);
-
- const [allToolkits, triggerTypes] = yield* Effect.all(
- [
- Effect.logDebug('Fetching toolkits...').pipe(Effect.flatMap(() => client.getToolkits())),
- Effect.logDebug('Fetching trigger types payloads...').pipe(
- Effect.flatMap(() => client.getTriggerTypes(triggerTypesAsEnums.length))
- ),
- ],
- { concurrency: 'unbounded' }
- );
-
- // Filter toolkits if --toolkits was specified
- const toolkits = hasToolkitsFilter
- ? client.filterToolkitsBySlugs(allToolkits, validatedToolkitSlugs)
- : allToolkits;
-
- if (hasToolkitsFilter) {
- yield* Console.log(
- `Filtering to ${toolkits.length} toolkit(s): ${toolkits.map(t => t.slug).join(', ')}`
- );
- }
-
- // Only fetch tools if `--type-tools` was specified
- const typeableTools = yield* Match.value(typeTools).pipe(
- Match.when(true, typePredicate =>
- Effect.logDebug('Fetching tools...').pipe(
- Effect.flatMap(() => client.getTools(toolsAsEnums.length)),
- Effect.map(tools => ({
- withTypes: typePredicate,
- tools,
- }))
- )
- ),
- Match.when(false, typePredicate =>
- Effect.succeed({
- withTypes: typePredicate,
- tools: toolsAsEnums,
- })
- ),
- Match.exhaustive
- );
+ // Fetch data using two distinct strategies based on whether --toolkits filter is provided
+ const { toolkits, triggerTypes, typeableTools } = yield* toolkitSlugsFilter !== null
+ ? fetchFilteredData(client, toolkitSlugsFilter, typeTools)
+ : fetchAllData(client, typeTools);
yield* Console.log('Writing TypeScript type stubs to disk...');
const index = createToolkitIndex({ toolkits, typeableTools, triggerTypes });
diff --git a/ts/packages/cli/src/services/composio-clients-cached.ts b/ts/packages/cli/src/services/composio-clients-cached.ts
index 29855d7f1..fcc5af903 100644
--- a/ts/packages/cli/src/services/composio-clients-cached.ts
+++ b/ts/packages/cli/src/services/composio-clients-cached.ts
@@ -6,18 +6,20 @@ import { setupCacheDir } from 'src/effects/setup-cache-dir';
import { FORCE_CONFIG } from 'src/effects/force-config';
import { ComposioToolkitsRepository } from './composio-clients';
import { NodeOs } from './node-os';
-import { toolkitsFromJSON, toolkitsToJSON } from 'src/models/toolkits';
+import { toolkitsFromJSON, toolkitsToJSON, type Toolkits } from 'src/models/toolkits';
import {
toolsAsEnumsFromJSON,
toolsAsEnumsToJSON,
ToolsFromJSON,
ToolsToJSON,
+ type Tools,
} from 'src/models/tools';
import {
TriggerTypesAsEnumsFromJSON,
TriggerTypesAsEnumsToJSON,
TriggerTypesFromJSON,
TriggerTypesToJSON,
+ type TriggerTypes,
} from 'src/models/trigger-types';
import { ConfigLive } from './config';
@@ -39,7 +41,8 @@ function createCachedEffect<T, E, R>(
cacheFileName: string,
decoder: (input: string) => Effect.Effect<T, ParseResult.ParseError>,
encoder: (input: T) => Effect.Effect<string, ParseResult.ParseError>,
- computation: Effect.Effect<T, E, R>
+ computation: Effect.Effect<T, E, R>,
+ cacheFilter?: (data: T) => T
): Effect.Effect<T, E, R> {
// First define the cache-handling function that will run with all required services
const cacheEffect = Effect.gen(function* () {
@@ -68,7 +71,7 @@ function createCachedEffect<T, E, R>(
);
if (Option.isSome(cachedResult)) {
- return cachedResult.value;
+ return cacheFilter ? cacheFilter(cachedResult.value) : cachedResult.value;
}
}
@@ -124,6 +127,20 @@ export const ComposioToolkitsRepositoryCached = Layer.effect(
);
},
+ getToolkitsBySlugs: slugs => {
+ const cacheFilter = (data: Toolkits): Toolkits => {
+ const slugSet = new Set(slugs.map(s => s.toUpperCase()));
+ return data.filter(t => slugSet.has(t.slug.toUpperCase()));
+ };
+ return createCachedEffect(
+ CACHE_FILES.toolkits,
+ toolkitsFromJSON,
+ toolkitsToJSON,
+ underlyingRepository.getToolkitsBySlugs(slugs),
+ cacheFilter
+ );
+ },
+
getToolsAsEnums: () => {
return createCachedEffect(
CACHE_FILES.toolsAsEnums,
@@ -142,23 +159,37 @@ export const ComposioToolkitsRepositoryCached = Layer.effect(
);
},
- getTriggerTypes: (limit: number) => {
+ getTriggerTypes: (toolkitSlugs?: ReadonlyArray<string>) => {
+ const cacheFilter =
+ toolkitSlugs && toolkitSlugs.length > 0
+ ? (data: TriggerTypes): TriggerTypes => {
+ const prefixes = toolkitSlugs.map(s => `${s.toUpperCase()}_`);
+ return data.filter(t => prefixes.some(p => t.slug.toUpperCase().startsWith(p)));
+ }
+ : undefined;
return createCachedEffect(
- // We don't care about the limit in the cache file name
CACHE_FILES.triggerTypes,
TriggerTypesFromJSON,
TriggerTypesToJSON,
- underlyingRepository.getTriggerTypes(limit)
+ underlyingRepository.getTriggerTypes(toolkitSlugs),
+ cacheFilter
);
},
- getTools: (limit: number) => {
+ getTools: (toolkitSlugs?: ReadonlyArray<string>) => {
+ const cacheFilter =
+ toolkitSlugs && toolkitSlugs.length > 0
+ ? (data: Tools): Tools => {
+ const prefixes = toolkitSlugs.map(s => `${s.toUpperCase()}_`);
+ return data.filter(t => prefixes.some(p => t.slug.toUpperCase().startsWith(p)));
+ }
+ : undefined;
return createCachedEffect(
- // We don't care about the limit in the cache file name
CACHE_FILES.tools,
ToolsFromJSON,
ToolsToJSON,
- underlyingRepository.getTools(limit)
+ underlyingRepository.getTools(toolkitSlugs),
+ cacheFilter
);
},
diff --git a/ts/packages/cli/src/services/composio-clients.ts b/ts/packages/cli/src/services/composio-clients.ts
index 0dae3cb38..93cbf2bd8 100644
--- a/ts/packages/cli/src/services/composio-clients.ts
+++ b/ts/packages/cli/src/services/composio-clients.ts
@@ -66,6 +66,24 @@ export const ToolkitsResponse = Schema.Struct({
}).annotations({ identifier: 'ToolkitsResponse' });
export type ToolkitsResponse = Schema.Schema.Type<typeof ToolkitsResponse>;
+// Similar to Toolkits, without auth_schemes, with auth_config_details instead
+export const ToolkitRetrieveResponse = Schema.Struct({
+ name: Schema.String,
+ slug: Schema.Trim.pipe(Schema.nonEmptyString()),
+ is_local_toolkit: Schema.Boolean,
+ composio_managed_auth_schemes: Schema.optionalWith(Schema.Array(Schema.String), {
+ default: () => [],
+ }),
+ no_auth: Schema.optionalWith(Schema.Boolean, { default: () => false }),
+ meta: Schema.Struct({
+ description: Schema.optionalWith(Schema.String, { default: () => '' }),
+ categories: Schema.optionalWith(Schema.Array(Schema.Unknown), { default: () => [] }),
+ created_at: Schema.DateTimeUtc,
+ updated_at: Schema.DateTimeUtc,
+ }),
+}).annotations({ identifier: 'ToolkitRetrieveResponse' });
+export type ToolkitRetrieveResponse = Schema.Schema.Type<typeof ToolkitRetrieveResponse>;
+
export const ToolsAsEnumsResponse = ToolsAsEnums;
export type ToolsAsEnumsResponse = Schema.Schema.Type<typeof ToolsAsEnumsResponse>;
@@ -246,13 +264,18 @@ type PaginatedSchema = Schema.Schema<
any
>;
+// Maximum items per page allowed by the server
+const MAX_PAGE_SIZE = 1000;
+
+// Maximum concurrent requests per each endpoint
+const MAX_CONCURRENT_REQUESTS_PER_ENDPOINT = 4;
+
// Utility function for calling paginated Composio API endpoints.
-// Automatically fetches all pages until the specified limit is reached.
+// Automatically fetches all pages, using MAX_PAGE_SIZE per request.
const callClientWithPagination = <T, S extends PaginatedSchema>(
clientSingleton: ComposioClientSingleton,
- apiCall: (client: _RawComposioClient, cursor?: string) => APIPromise<T>,
- responseSchema: S,
- limit: number
+ apiCall: (client: _RawComposioClient, cursor?: string, limit?: number) => APIPromise<T>,
+ responseSchema: S
): Effect.Effect<
{ data: Schema.Schema.Type<S>; metrics: Metrics },
HttpError | NoSuchElementException
@@ -265,7 +288,7 @@ const callClientWithPagination = <T, S extends PaginatedSchema>(
const fetchPage = (cursor?: string): Effect.Effect<StreamedResponse, HttpServerError> =>
Effect.gen(function* () {
const response = yield* Effect.tryPromise({
- try: () => apiCall(client, cursor).asResponse(),
+ try: () => apiCall(client, cursor, MAX_PAGE_SIZE).asResponse(),
catch: e => {
const decodedOpt = Schema.decodeUnknownOption(HttpErrorResponse)(e);
@@ -313,7 +336,8 @@ const callClientWithPagination = <T, S extends PaginatedSchema>(
let currentCursor: string | null = null;
let totalPages = 0;
- while (allItems.length < limit) {
+ // Fetch all pages using MAX_PAGE_SIZE per request
+ while (true) {
const { json, byteSize } = yield* fetchPage(currentCursor ?? undefined);
totalByteSize += byteSize;
totalRequests += 1;
@@ -334,7 +358,7 @@ const callClientWithPagination = <T, S extends PaginatedSchema>(
return {
data: {
- items: allItems.slice(0, limit),
+ items: allItems,
total_pages: totalPages,
next_cursor: currentCursor,
} as DecodedPage,
@@ -411,21 +435,42 @@ export class ComposioClientLive extends Effect.Service<ComposioClientLive>()(
toolkits: {
/**
* Retrieves a comprehensive list of toolkits that are available to the authenticated project.
- * If limit is provided, automatically handles pagination to fetch up to that many items.
+ * Automatically handles pagination to fetch all items.
*/
- list: (params?: { limit?: number }) =>
- params?.limit
- ? withMetrics(
- callClientWithPagination(
- clientSingleton,
- (client, cursor) => client.toolkits.list({ cursor }),
- ToolkitsResponse,
- params.limit
- )
- )
- : withMetrics(
- callClient(clientSingleton, client => client.toolkits.list(), ToolkitsResponse)
- ),
+ list: () =>
+ withMetrics(
+ callClientWithPagination(
+ clientSingleton,
+ (client, cursor, limit) => client.toolkits.list({ cursor, limit }),
+ ToolkitsResponse
+ )
+ ),
+ /**
+ * Retrieves a single toolkit by its slug.
+ * Transforms the response to match the Toolkit schema.
+ */
+ retrieve: (slug: string) =>
+ withMetrics(
+ callClient(
+ clientSingleton,
+ client => client.toolkits.retrieve(slug),
+ ToolkitRetrieveResponse
+ )
+ ).pipe(
+ // Transform to Toolkit format by adding missing fields
+ Effect.map(
+ retrieved =>
+ ({
+ name: retrieved.name,
+ slug: retrieved.slug,
+ auth_schemes: [], // retrieve endpoint doesn't return auth_schemes
+ composio_managed_auth_schemes: retrieved.composio_managed_auth_schemes,
+ is_local_toolkit: retrieved.is_local_toolkit,
+ no_auth: retrieved.no_auth,
+ meta: retrieved.meta,
+ }) satisfies Toolkit
+ )
+ ),
},
tools: {
/**
@@ -440,16 +485,17 @@ export class ComposioClientLive extends Effect.Service<ComposioClientLive>()(
)
),
/**
- * Retrieve a list of tools, automatically handling pagination to fetch up to $limit items.
+ * Retrieve a list of tools, automatically handling pagination.
+ * @param toolkitSlugs - Optional array of toolkit slugs to filter by
*/
- list: (params: { limit: number }) =>
+ list: (toolkitSlugs?: ReadonlyArray<string>) =>
withMetrics(
callClientWithPagination(
clientSingleton,
- (client, cursor) =>
- client.tools.list({ cursor, limit: params.limit, toolkit_versions: 'latest' }),
- ToolsResponse,
- params.limit
+ (client, cursor, limit) =>
+ client.tools.list({
+ cursor, toolkit_slug: toolkitSlugs?.join(',') ?? '', toolkit_versions: 'latest', limit, }),
+ ToolsResponse
)
),
},
@@ -466,15 +512,20 @@ export class ComposioClientLive extends Effect.Service<ComposioClientLive>()(
)
),
/**
- * Retrieve a list of trigger types, automatically handling pagination to fetch up to $limit items.
+ * Retrieve a list of trigger types, automatically handling pagination.
+ * @param toolkitSlugs - Optional array of toolkit slugs to filter by
*/
- list: (params: { limit: number }) =>
+ list: (toolkitSlugs?: ReadonlyArray<string>) =>
withMetrics(
callClientWithPagination(
clientSingleton,
- (client, cursor) => client.triggersTypes.list({ cursor, limit: params.limit }),
- TriggerTypesResponse,
- params.limit
+ (client, cursor, limit) =>
+ client.triggersTypes.list({
+ cursor,
+ limit,
+ toolkit_slugs: toolkitSlugs ? [...toolkitSlugs] : undefined,
+ }),
+ TriggerTypesResponse
)
),
},
@@ -515,8 +566,8 @@ export class ComposioToolkitsRepository extends Effect.Service<ComposioToolkitsR
effect: Effect.gen(function* () {
const client = yield* ComposioClientLive;
- const getToolkits = (limit?: number) =>
- client.toolkits.list({ limit }).pipe(
+ const getToolkits = () =>
+ client.toolkits.list().pipe(
Effect.map(response => response.items),
Effect.flatMap(
Effect.fn(function* (toolkits) {
@@ -528,12 +579,49 @@ export class ComposioToolkitsRepository extends Effect.Service<ComposioToolkitsR
)
);
+ /**
+ * Fetches specific toolkits by their slugs.
+ * Makes parallel API calls to retrieve each toolkit.
+ * @param slugs - Array of toolkit slugs to fetch
+ */
+ const getToolkitsBySlugs = (slugs: ReadonlyArray<string>) =>
+ Effect.all(
+ slugs.map(slug =>
+ client.toolkits.retrieve(slug).pipe(
+ Effect.catchTag('services/HttpServerError', () =>
+ Effect.fail(
+ new InvalidToolkitsError({
+ invalidToolkits: [slug],
+ availableToolkits: [],
+ })
+ )
+ )
+ )
+ ),
+ { concurrency: MAX_CONCURRENT_REQUESTS_PER_ENDPOINT }
+ ).pipe(
+ Effect.flatMap(
+ Effect.fn(function* (toolkits) {
+ // Sort apps by slug.
+ // TODO: make sure this happens on the server-side.
+ const orderBySlug = Order.mapInput(Order.string, (app: Toolkit) => app.slug);
+ return Array.sort(toolkits, orderBySlug) as ReadonlyArray<Toolkit>;
+ })
+ )
+ );
+
return {
getToolkits,
+ getToolkitsBySlugs,
getMetrics: () => client.getMetrics(),
getToolsAsEnums: () => client.tools.retrieveEnum(),
- getTools: (limit: number) =>
- client.tools.list({ limit }).pipe(
+ /**
+ * Fetches tools with optional toolkit filtering.
+ * When toolkitSlugs is provided, fetches all matching tools.
+ * @param toolkitSlugs - Optional array of toolkit slugs to filter by
+ */
+ getTools: (toolkitSlugs?: ReadonlyArray<string>) =>
+ client.tools.list(toolkitSlugs).pipe(
Effect.map(response => response.items),
Effect.flatMap(
Effect.fn(function* (tools) {
@@ -545,8 +633,13 @@ export class ComposioToolkitsRepository extends Effect.Service<ComposioToolkitsR
)
),
getTriggerTypesAsEnums: () => client.triggersTypes.retrieveEnum(),
- getTriggerTypes: (limit: number) =>
- client.triggersTypes.list({ limit }).pipe(
+ /**
+ * Fetches trigger types with optional toolkit filtering.
+ * When toolkitSlugs is provided, fetches all matching trigger types.
+ * @param toolkitSlugs - Optional array of toolkit slugs to filter by
+ */
+ getTriggerTypes: (toolkitSlugs?: ReadonlyArray<string>) =>
+ client.triggersTypes.list(toolkitSlugs).pipe(
Effect.map(response => response.items),
Effect.flatMap(
Effect.fn(function* (triggerTypes) {
diff --git a/ts/packages/cli/test/__utils__/services/test-layer.ts b/ts/packages/cli/test/__utils__/services/test-layer.ts
index e6e26bfd4..9b74b09a9 100644
--- a/ts/packages/cli/test/__utils__/services/test-layer.ts
+++ b/ts/packages/cli/test/__utils__/services/test-layer.ts
@@ -92,11 +92,42 @@ export const TestLayer = (input?: TestLiveInput) =>
ComposioToolkitsRepository,
new ComposioToolkitsRepository({
getToolkits: () => Effect.succeed(toolkitsData.toolkits),
+ getToolkitsBySlugs: (slugs: ReadonlyArray<string>) => {
+ const normalizedSlugs = new Set(slugs.map(s => String.toLowerCase(s)));
+ const found = toolkitsData.toolkits.filter(t =>
+ normalizedSlugs.has(String.toLowerCase(t.slug))
+ );
+ if (found.length !== slugs.length) {
+ const foundSlugs = new Set(found.map(t => String.toLowerCase(t.slug)));
+ const notFound = slugs.filter(s => !foundSlugs.has(String.toLowerCase(s)));
+ return Effect.fail(
+ new InvalidToolkitsError({
+ invalidToolkits: [...notFound],
+ availableToolkits: toolkitsData.toolkits.map(t => t.slug),
+ })
+ );
+ }
+ return Effect.succeed(found);
+ },
getMetrics: () => Effect.succeed({ byteSize: 0, requests: 0 }),
getToolsAsEnums: () => Effect.succeed(toolkitsData.tools.map(tool => tool.slug)),
getTriggerTypesAsEnums: () => Effect.succeed(toolkitsData.triggerTypesAsEnums),
- getTriggerTypes: limit => Effect.succeed(toolkitsData.triggerTypes.slice(0, limit)),
- getTools: limit => Effect.succeed(toolkitsData.tools.slice(0, limit)),
+ getTriggerTypes: (toolkitSlugs?: ReadonlyArray<string>) => {
+ let triggers = toolkitsData.triggerTypes;
+ if (toolkitSlugs && toolkitSlugs.length > 0) {
+ const prefixes = toolkitSlugs.map(s => `${s.toUpperCase()}_`);
+ triggers = triggers.filter(t => prefixes.some(p => t.slug.startsWith(p)));
+ }
+ return Effect.succeed(triggers);
+ },
+ getTools: (toolkitSlugs?: ReadonlyArray<string>) => {
+ let tools = toolkitsData.tools;
+ if (toolkitSlugs && toolkitSlugs.length > 0) {
+ const prefixes = toolkitSlugs.map(s => `${s.toUpperCase()}_`);
+ tools = tools.filter(t => prefixes.some(p => t.slug.startsWith(p)));
+ }
+ return Effect.succeed(tools);
+ },
validateToolkits: (toolkitSlugs: ReadonlyArray<string>) => {
const normalizedInputSlugs = toolkitSlugs.map(slug => String.toLowerCase(slug));
const availableSlugs = toolkitsData.toolkits.map(toolkit =>