262
}).annotations({ identifier: 'ToolsResponse' });
263
export type ToolsResponse = Schema.Schema.Type<typeof ToolsResponse>;
264
265
+export const ToolDetailedResponse = Schema.Struct({
266
+ name: Schema.String,
267
+ slug: Schema.String,
268
+ description: Schema.String,
269
+ tags: Schema.Array(Schema.String),
270
+ available_versions: Schema.Array(Schema.String),
271
+ input_parameters: Schema.Record({ key: Schema.String, value: Schema.Unknown }),
272
+ output_parameters: Schema.Record({ key: Schema.String, value: Schema.Unknown }),
273
+ no_auth: Schema.optionalWith(Schema.Boolean, { default: () => false }),
274
+ toolkit: Schema.optionalWith(
275
+ Schema.Struct({
276
+ name: Schema.String,
277
+ slug: Schema.String,
278
+ }),
279
+ { default: () => ({ name: '', slug: '' }) }
280
+ ),
281
+}).annotations({ identifier: 'ToolDetailedResponse' });
282
+export type ToolDetailedResponse = Schema.Schema.Type<typeof ToolDetailedResponse>;
283
+
284
export const TriggerTypesAsEnumsResponse = TriggerTypesAsEnums;
285
export type TriggerTypesAsEnumsResponse = Schema.Schema.Type<typeof TriggerTypesAsEnumsResponse>;
286
640
}
641
) {}
642
643
+/**
644
+ * Build the `tools` namespace for ComposioClientLive.
645
+ * Extracted to keep the main generator under the max-lines-per-function limit.
646
+ */
647
+function buildToolsNamespace(
648
+ clientSingleton: ComposioClientSingleton,
649
+ withMetrics: <A, E, R>(
650
+ effect: Effect.Effect<{ data: A; metrics: Metrics }, E, R>
651
+ ) => Effect.Effect<A, E, R>
652
+) {
653
+ return {
654
+ /**
655
+ * Retrieve a list of all available tool enumeration values (tool slugs) for the project.
656
+ */
657
+ retrieveEnum: () =>
658
+ withMetrics(
659
+ callClient(clientSingleton, client => client.tools.retrieveEnum(), ToolsAsEnumsResponse)
660
+ ),
661
+ /**
662
+ * Retrieve a list of tools, automatically handling pagination.
663
+ * It always fetches the latest version of tools for each toolkit.
664
+ * For more granular toolkit version control, use `listByVersionSpecs`.
665
+ * @param toolkitSlugs - Array of toolkit slugs to filter by
666
+ */
667
+ list: (toolkitSlugs: ReadonlyArray<string>) =>
668
+ withMetrics(
669
+ callClientWithPagination(
670
+ clientSingleton,
671
+ (client, cursor, limit) =>
672
+ client.tools.list({
673
+ cursor,
674
+ toolkit_slug: toolkitSlugs.length > 0 ? toolkitSlugs.join(',') : undefined,
675
+ toolkit_versions: 'latest',
676
+ limit,
677
+ }),
678
+ ToolsResponse
679
+ )
680
+ ),
681
+ /**
682
+ * Retrieve tools for multiple toolkits, grouped by version.
683
+ * Makes parallel API calls for each version group, then merges results.
684
+ * @param specs - Array of toolkit version specifications
685
+ */
686
+ listByVersionSpecs: (specs: ReadonlyArray<ToolkitVersionSpec>) =>
687
+ Effect.gen(function* () {
688
+ const grouped = groupByVersion(specs);
689
+ const versionGroups = [...grouped.entries()];
690
+
691
+ // Fetch all version groups in parallel with bounded concurrency
692
+ const responses = yield* Effect.all(
693
+ versionGroups.map(([version, slugs]) =>
694
+ withMetrics(
695
+ callClientWithPagination(
696
+ clientSingleton,
697
+ (client, cursor, limit) =>
698
+ client.tools.list({
699
+ cursor,
700
+ toolkit_slug: slugs.join(','),
701
+ toolkit_versions: version,
702
+ limit,
703
+ }),
704
+ ToolsResponse
705
+ )
706
+ )
707
+ ),
708
+ { concurrency: MAX_CONCURRENT_REQUESTS_PER_ENDPOINT }
709
+ );
710
+
711
+ // Merge all tools from all version groups
712
+ const allTools = responses.flatMap(response => response.items);
713
+ return { items: allTools };
714
+ }),
715
+ /**
716
+ * Search tools with optional filters. Returns a single page of results (no auto-pagination).
717
+ * @param params - Search/filter parameters
718
+ */
719
+ search: (params: {
720
+ search?: string;
721
+ toolkit_slug?: string;
722
+ tags?: string;
723
+ limit?: number;
724
+ cursor?: string;
725
+ }) =>
726
+ withMetrics(
727
+ callClient(
728
+ clientSingleton,
729
+ client =>
730
+ client.tools.list({
731
+ search: params.search,
732
+ toolkit_slug: params.toolkit_slug,
733
+ tags: params.tags ? params.tags.split(',').map(t => t.trim()) : undefined,
734
+ limit: params.limit,
735
+ cursor: params.cursor,
736
+ toolkit_versions: 'latest',
737
+ }),
738
+ ToolsResponse
739
+ )
740
+ ),
741
+ /**
742
+ * Retrieves detailed info about a single tool by slug.
743
+ * @param slug - Tool slug (e.g. "GMAIL_SEND_EMAIL")
744
+ */
745
+ retrieve: (slug: string) =>
746
+ withMetrics(
747
+ callClient(
748
+ clientSingleton,
749
+ client => client.tools.retrieve(slug, { toolkit_versions: 'latest' }),
750
+ ToolDetailedResponse
751
+ )
752
+ ),
753
+ };
754
+}
755
+
756
// Service that wraps the raw Composio client, which is shared by all client services.
757
export class ComposioClientLive extends Effect.Service<ComposioClientLive>()(
758
'services/ComposioClientLive',
877
)
878
).pipe(Effect.map(response => response.items)),
879
},
748
- tools: {
749
- /**
750
- * Retrieve a list of all available tool enumeration values (tool slugs) for the project.
751
- */
752
- retrieveEnum: () =>
753
- withMetrics(
754
- callClient(
755
- clientSingleton,
756
- client => client.tools.retrieveEnum(),
757
- ToolsAsEnumsResponse
758
- )
759
- ),
760
- /**
761
- * Retrieve a list of tools, automatically handling pagination.
762
- * It always fetches the latest version of tools for each toolkit.
763
- * For more granular toolkit version control, use `listByVersionSpecs`.
764
- * @param toolkitSlugs - Array of toolkit slugs to filter by
765
- */
766
- list: (toolkitSlugs: ReadonlyArray<string>) =>
767
- withMetrics(
768
- callClientWithPagination(
769
- clientSingleton,
770
- (client, cursor, limit) =>
771
- client.tools.list({
772
- cursor,
773
- toolkit_slug: toolkitSlugs.length > 0 ? toolkitSlugs.join(',') : undefined,
774
- toolkit_versions: 'latest',
775
- limit,
776
- }),
777
- ToolsResponse
778
- )
779
- ),
780
- /**
781
- * Retrieve tools for multiple toolkits, grouped by version.
782
- * Makes parallel API calls for each version group, then merges results.
783
- * @param specs - Array of toolkit version specifications
784
- */
785
- listByVersionSpecs: (specs: ReadonlyArray<ToolkitVersionSpec>) =>
786
- Effect.gen(function* () {
787
- const grouped = groupByVersion(specs);
788
- const versionGroups = [...grouped.entries()];
789
-
790
- // Fetch all version groups in parallel with bounded concurrency
791
- const responses = yield* Effect.all(
792
- versionGroups.map(([version, slugs]) =>
793
- withMetrics(
794
- callClientWithPagination(
795
- clientSingleton,
796
- (client, cursor, limit) =>
797
- client.tools.list({
798
- cursor,
799
- toolkit_slug: slugs.join(','),
800
- toolkit_versions: version,
801
- limit,
802
- }),
803
- ToolsResponse
804
- )
805
- )
806
- ),
807
- { concurrency: MAX_CONCURRENT_REQUESTS_PER_ENDPOINT }
808
- );
809
-
810
- // Merge all tools from all version groups
811
- const allTools = responses.flatMap(response => response.items);
812
- return { items: allTools };
813
- }),
814
- },
880
+ tools: buildToolsNamespace(clientSingleton, withMetrics),
881
triggersTypes: {
882
/**
883
* Retrieves a list of all available trigger type enum values that can be used across the API.
1136
* Retrieves all available toolkit categories.
1137
*/
1138
getCategories: () => client.toolkits.retrieveCategories(),
1139
+ /**
1140
+ * Searches tools with optional filters. Returns a single page of results.
1141
+ * @param params - Search/filter parameters
1142
+ */
1143
+ searchTools: (params: {
1144
+ search?: string;
1145
+ toolkit_slug?: string;
1146
+ tags?: string;
1147
+ limit?: number;
1148
+ cursor?: string;
1149
+ }) => client.tools.search(params),
1150
+ /**
1151
+ * Retrieves detailed info about a single tool by slug.
1152
+ * @param slug - Tool slug (e.g. "GMAIL_SEND_EMAIL")
1153
+ */
1154
+ getToolDetailed: (slug: string) => client.tools.retrieve(slug),
1155
};
1156
}),
1157
dependencies: [ComposioClientLive.Default],