Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
TypeScript agentic-aiagentsaiai-agentsaiagentsdeveloper-toolsfunction-callinggpt-4javascriptjsllmllmopsmcppythonremote-mcp-serverssetypescript
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.jsonindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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 servicesconst 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 nameCACHE_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 nameCACHE_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.tsindex 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<ComposioToolkitsReffect: 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.tsindex 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 =>