@composio/core
Version:
1,458 lines (1,457 loc) • 192 kB
text/typescript
import { D as ToolkitVersionParam, F as ProviderOptions, G as BaseComposioProvider, I as SessionExecuteMetaModifiers, Jt as ExecuteToolFnOptions, K as BaseNonAgenticProvider, N as ExecuteToolModifiers, Wt as McpUrlResponse, a as SchemaModifierOptions, b as ToolRetrievalOptions, d as ToolExecuteResponse$1, l as ToolExecuteParams, m as ToolListParams, o as Tool, p as ToolList, s as ToolExecuteMetaParams, v as ToolProxyParams, zt as McpServerGetResponse } from "./tool.types-bencsexi.mjs";
import { E as Session, Ht as CreateConnectedAccountLinkOptions, I as ToolRouterCreateSessionConfig, It as ConnectedAccountRetrieveResponse, Kt as CreateConnectedAccountOptions, Pt as ConnectedAccountRefreshOptions, Tt as ConnectionRequest, c as CustomToolInputParameter, jt as ConnectedAccountListResponse, kt as ConnectedAccountListParams, l as CustomToolOptions } from "./customTool.types-B-4lZeSS.mjs";
import ComposioClient, { Composio } from "@composio/client";
import z, { z as z$1 } from "zod/v3";
import { OpenAI } from "openai";
import { Files } from "#files";
import { ToolGetInputParams, ToolGetInputResponse, ToolProxyResponse, ToolRetrieveEnumResponse } from "@composio/client/resources/tools";
import { TriggersTypeRetrieveEnumResponse } from "@composio/client/resources/index";
import { AuthConfigDeleteResponse, AuthConfigUpdateResponse, AuthConfigUpdateStatusResponse } from "@composio/client/resources/auth-configs";
import { ConnectedAccountDeleteResponse, ConnectedAccountRefreshResponse, ConnectedAccountUpdateStatusParams, ConnectedAccountUpdateStatusResponse } from "@composio/client/resources/connected-accounts";
import { Stream } from "openai/streaming";
//#region src/models/Tools.d.ts
/**
* This class is used to manage tools in the Composio SDK.
* It provides methods to list, get, and execute tools.
*/
declare class Tools<TToolCollection, TTool, TProvider extends BaseComposioProvider<TToolCollection, TTool, unknown>> {
private client;
private readonly customTools;
private provider;
private autoUploadDownloadFiles;
private toolkitVersions;
constructor(client: ComposioClient, config?: ComposioConfig<TProvider>);
/**
* Transforms tool data from snake_case API format to camelCase for internal SDK use.
*
* This method standardizes the property naming convention for tools retrieved from the Composio API,
* making them more consistent with JavaScript/TypeScript conventions.
*
* @param {ToolRetrieveResponse | ComposioToolListResponse['items'][0]} tool - The tool object to transform
* @returns {Tool} The transformed tool with camelCase properties
*
* @private
*/
private transformToolCases;
/**
* Transforms tool execution response from snake_case API format to camelCase.
*
* This method converts the response received from the Composio API to a standardized format
* with consistent property naming that follows JavaScript/TypeScript conventions.
*
* @param {ComposioToolExecuteResponse} response - The raw API response to transform
* @returns {ToolExecuteResponse} The transformed response with camelCase properties
*
* @private
*/
private transformToolExecuteResponse;
/**
* Applies the default schema modifiers to the tools
* @param tools - The tools to apply the default schema modifiers to
* @returns The tools with the default schema modifiers applied
*/
private applyDefaultSchemaModifiers;
/**
* Applies the before execute modifiers to the tool execution params
* @param options.toolSlug - The slug of the tool
* @param options.toolkitSlug - The slug of the toolkit
* @param options.params - The params of the tool execution
* @param modifier - The modifier to apply
* @returns The modified params
*/
private applyBeforeExecuteModifiers;
/**
* Applies the after execute modifiers to the tool execution result
* @param options.toolSlug - The slug of the tool
* @param options.toolkitSlug - The slug of the toolkit
* @param options.result - The result of the tool execution
* @param modifier - The modifier to apply
* @returns The modified result
*/
private applyAfterExecuteModifiers;
/**
* Lists all tools available in the Composio SDK including custom tools.
*
* This method fetches tools from the Composio API in raw format and combines them with
* any registered custom tools. The response can be filtered and modified as needed.
* It provides access to the underlying tool data without provider-specific wrapping.
*
* @param {ToolListParams} query - Query parameters to filter the tools (required)
* @param {GetRawComposioToolsOptions} [options] - Optional configuration for tool retrieval
* @param {TransformToolSchemaModifier} [options.modifySchema] - Function to transform tool schemas
* @returns {Promise<ToolList>} List of tools matching the query criteria
*
* @example
* ```typescript
* // Get tools from specific toolkits
* const githubTools = await composio.tools.getRawComposioTools({
* toolkits: ['github'],
* limit: 10
* });
*
* // Get specific tools by slug
* const specificTools = await composio.tools.getRawComposioTools({
* tools: ['GITHUB_GET_REPOS', 'HACKERNEWS_GET_USER']
* });
*
* // Get tools from specific toolkits
* const githubTools = await composio.tools.getRawComposioTools({
* toolkits: ['github'],
* limit: 10
* });
*
* // Get tools with schema transformation
* const customizedTools = await composio.tools.getRawComposioTools({
* toolkits: ['github'],
* limit: 5
* }, {
* modifySchema: ({ toolSlug, toolkitSlug, schema }) => {
* // Add custom properties to tool schema
* return {
* ...schema,
* customProperty: `Modified ${toolSlug} from ${toolkitSlug}`,
* tags: [...(schema.tags || []), 'customized']
* };
* }
* });
*
* // Search for tools
* const searchResults = await composio.tools.getRawComposioTools({
* search: 'user management'
* });
*
* // Get tools by authentication config
* const authSpecificTools = await composio.tools.getRawComposioTools({
* authConfigIds: ['auth_config_123']
* });
* ```
*/
getRawComposioTools(query: ToolListParams, options?: SchemaModifierOptions): Promise<ToolList>;
/**
* Fetches the meta tools for a tool router session.
* This method fetches the meta tools from the Composio API and transforms them to the expected format.
* It provides access to the underlying meta tool data without provider-specific wrapping.
*
* @param sessionId {string} The session id to get the meta tools for
* @param options {SchemaModifierOptions} Optional configuration for tool retrieval
* @param {TransformToolSchemaModifier} [options.modifySchema] - Function to transform the tool schema
* @returns {Promise<ToolList>} The list of meta tools
*
* @example
* ```typescript
* const metaTools = await composio.tools.getRawToolRouterMetaTools('session_123');
* console.log(metaTools);
* ```
*/
getRawToolRouterMetaTools(sessionId: string, options?: SchemaModifierOptions): Promise<ToolList>;
/**
* Retrieves a specific tool by its slug from the Composio API.
*
* This method fetches a single tool in raw format without provider-specific wrapping,
* providing direct access to the tool's schema and metadata. Tool versions are controlled
* at the Composio SDK initialization level through the `toolkitVersions` configuration.
*
* @param {string} slug - The unique identifier of the tool (e.g., 'GITHUB_GET_REPOS')
* @param {GetRawComposioToolBySlugOptions} [options] - Optional configuration for tool retrieval
* @param {TransformToolSchemaModifier} [options.modifySchema] - Function to transform the tool schema
* @returns {Promise<Tool>} The requested tool with its complete schema and metadata
*
* @example
* ```typescript
* // Get a tool by slug
* const tool = await composio.tools.getRawComposioToolBySlug('GITHUB_GET_REPOS');
* console.log(tool.name, tool.description);
*
* // Get a tool with schema transformation
* const customizedTool = await composio.tools.getRawComposioToolBySlug(
* 'SLACK_SEND_MESSAGE',
* {
* modifySchema: ({ toolSlug, toolkitSlug, schema }) => {
* return {
* ...schema,
* description: `Enhanced ${schema.description} with custom modifications`,
* customMetadata: {
* lastModified: new Date().toISOString(),
* toolkit: toolkitSlug
* }
* };
* }
* }
* );
*
* // Get a custom tool (will check custom tools first)
* const customTool = await composio.tools.getRawComposioToolBySlug('MY_CUSTOM_TOOL');
*
* // Access tool properties
* const githubTool = await composio.tools.getRawComposioToolBySlug('GITHUB_CREATE_ISSUE');
* console.log({
* slug: githubTool.slug,
* name: githubTool.name,
* toolkit: githubTool.toolkit?.name,
* version: githubTool.version,
* availableVersions: githubTool.availableVersions,
* inputParameters: githubTool.inputParameters
* });
* ```
*/
getRawComposioToolBySlug(slug: string, options?: ToolRetrievalOptions): Promise<Tool>;
/**
* Get a list of tools from Composio based on filters.
* This method fetches the tools from the Composio API and wraps them using the provider.
*
* @param {string} userId - The user id to get the tools for
* @param {ToolListParams} filters - The filters to apply when fetching tools
* @param {ProviderOptions<TProvider>} [options] - Optional provider options including modifiers
* @returns {Promise<ReturnType<T['wrapTools']>>} The wrapped tools collection
*
* @example
* ```typescript
* // Get tools from the GitHub toolkit
* const tools = await composio.tools.get('default', {
* toolkits: ['github'],
* limit: 10
* });
*
* // Get tools with search
* const searchTools = await composio.tools.get('default', {
* search: 'user',
* limit: 10
* });
*
* // Get a specific tool by slug
* const hackerNewsUserTool = await composio.tools.get('default', 'HACKERNEWS_GET_USER');
*
* // Get a tool with schema modifications
* const tool = await composio.tools.get('default', 'GITHUB_GET_REPOS', {
* modifySchema: (toolSlug, toolkitSlug, schema) => {
* // Customize the tool schema
* return {...schema, description: 'Custom description'};
* }
* });
* ```
*/
get<T extends TProvider>(userId: string, filters: ToolListParams, options?: ProviderOptions<TProvider>): Promise<ReturnType<T['wrapTools']>>;
/**
* Get a specific tool by its slug.
* This method fetches the tool from the Composio API and wraps it using the provider.
*
* @param {string} userId - The user id to get the tool for
* @param {string} slug - The slug of the tool to fetch
* @param {ProviderOptions<TProvider>} [options] - Optional provider options including modifiers
* @returns {Promise<ReturnType<T['wrapTools']>>} The wrapped tool
*
* @example
* ```typescript
* // Get a specific tool by slug
* const hackerNewsUserTool = await composio.tools.get('default', 'HACKERNEWS_GET_USER');
*
* // Get a tool with schema modifications
* const tool = await composio.tools.get('default', 'GITHUB_GET_REPOS', {
* modifySchema: (toolSlug, toolkitSlug, schema) => {
* // Customize the tool schema
* return {...schema, description: 'Custom description'};
* }
* });
* ```
*/
get<T extends TProvider>(userId: string, slug: string, options?: ProviderOptions<TProvider>): Promise<ReturnType<T['wrapTools']>>;
/**
* @internal
* Creates a global execute tool function.
* This function is used by providers to execute tools.
* It skips the version check for provider controlled execution.
* @returns {GlobalExecuteToolFn} The global execute tool function
*/
private createExecuteFnForProviders;
/**
* @internal
* Utility to wrap a given set of tools in the format expected by the provider
*
* @param userId - The user id to get the tools for
* @param tools - The tools to wrap
* @param modifiers - The modifiers to be applied to the tools
* @returns The wrapped tools
*/
wrapToolsForProvider<T extends TProvider>(userId: string, tools: Tool[], modifiers?: ExecuteToolModifiers): ReturnType<T['wrapTools']>;
/**
* @internal
* Utility to wrap a given set of tools in the format expected by the tool router
*
* @param {string} sessionId - The session id to execute the tool for
* @param {Tool[]} tools - The tools to wrap
* @param {SessionExecuteMetaModifiers} modifiers - The modifiers to apply to the tool
* @returns {Tool[]} The wrapped tools
*/
wrapToolsForToolRouter(sessionId: string, tools: Tool[], modifiers?: SessionExecuteMetaModifiers): Tool[];
/**
* @internal
* @description
* Creates a function that executes a tool.
* This function is used by agentic providers to execute the tool
*
* @param {string} userId - The user id
* @param {ExecuteToolModifiers} modifiers - The modifiers to be applied to the tool
* @returns {ExecuteToolFn} The execute tool function
*/
private createExecuteToolFn;
/**
* @internal
* Creates a function that executes a tool for a tool router session
*
* @param {string} sessionId - The session id to execute the tool for
* @param {SessionExecuteMetaModifiers} modifiers - The modifiers to apply to the tool
* @returns {ExecuteToolFn} The execute tool function
*/
private createExecuteToolFnForToolRouter;
/**
* @internal
* Executes a composio tool via API without modifiers
* @param tool - The tool to execute
* @param body - The body of the tool execution
* @returns The response from the tool execution
*/
private executeComposioTool;
/**
* Executes a given tool with the provided parameters.
*
* This method calls the Composio API or a custom tool handler to execute the tool and returns the response.
* It automatically determines whether to use a custom tool or a Composio API tool based on the slug.
*
* **Version Control:**
* By default, manual tool execution requires a specific toolkit version. If the version resolves to "latest",
* the execution will throw a `ComposioToolVersionRequiredError` unless `dangerouslySkipVersionCheck` is set to `true`.
* This helps prevent unexpected behavior when new toolkit versions are released.
*
* @param {string} slug - The slug/ID of the tool to be executed
* @param {ToolExecuteParams} body - The parameters to be passed to the tool
* @param {string} [body.version] - The specific version of the tool to execute (e.g., "20250909_00")
* @param {boolean} [body.dangerouslySkipVersionCheck] - Skip version validation for "latest" version (use with caution)
* @param {string} [body.userId] - The user ID to execute the tool for
* @param {string} [body.connectedAccountId] - The connected account ID to use for authenticated tools
* @param {Record<string, unknown>} [body.arguments] - The arguments to pass to the tool
* @param {ExecuteToolModifiers} [modifiers] - Optional modifiers to transform the request or response
* @returns {Promise<ToolExecuteResponse>} - The response from the tool execution
*
* @throws {ComposioCustomToolsNotInitializedError} If the CustomTools instance is not initialized
* @throws {ComposioConnectedAccountNotFoundError} If the connected account is not found
* @throws {ComposioToolNotFoundError} If the tool with the given slug is not found
* @throws {ComposioToolVersionRequiredError} If version resolves to "latest" and dangerouslySkipVersionCheck is not true
* @throws {ComposioToolExecutionError} If there is an error during tool execution
*
* @example Execute with a specific version (recommended for production)
* ```typescript
* const result = await composio.tools.execute('GITHUB_GET_REPOS', {
* userId: 'default',
* version: '20250909_00',
* arguments: { owner: 'composio' }
* });
* ```
*
* @example Execute with dangerouslySkipVersionCheck (not recommended for production)
* ```typescript
* const result = await composio.tools.execute('HACKERNEWS_GET_USER', {
* userId: 'default',
* arguments: { userId: 'pg' },
* dangerouslySkipVersionCheck: true // Allows execution with "latest" version
* });
* ```
*
* @example Execute with SDK-level toolkit versions configuration
* ```typescript
* // If toolkitVersions are set during Composio initialization, no need to pass version
* const composio = new Composio({ toolkitVersions: { github: '20250909_00' } });
* const result = await composio.tools.execute('GITHUB_GET_REPOS', {
* userId: 'default',
* arguments: { owner: 'composio' }
* });
* ```
*
* @example Execute with modifiers
* ```typescript
* const result = await composio.tools.execute('GITHUB_GET_ISSUES', {
* userId: 'default',
* version: '20250909_00',
* arguments: { owner: 'composio', repo: 'sdk' }
* }, {
* beforeExecute: ({ toolSlug, toolkitSlug, params }) => {
* console.log(`Executing ${toolSlug} from ${toolkitSlug}`);
* return params;
* },
* afterExecute: ({ toolSlug, toolkitSlug, result }) => {
* console.log(`Completed ${toolSlug}`);
* return result;
* }
* });
* ```
*/
execute(slug: string, body: ToolExecuteParams, modifiers?: ExecuteToolModifiers): Promise<ToolExecuteResponse$1>;
/**
* Executes a composio meta tool based on tool router session
*
* @param {string} toolSlug - The slug of the tool to execute
* @param {ToolExecuteMetaParams} body - The execution parameters
* @param {string} body.sessionId - The session id to execute the tool for
* @param {Record<string, unknown>} body.arguments - The input to pass to the tool
* @param {SessionExecuteMetaModifiers} modifiers - The modifiers to apply to the tool
* @returns {Promise<ToolExecuteResponse>} The response from the tool execution
*/
executeMetaTool(toolSlug: string, body: ToolExecuteMetaParams, modifiers?: SessionExecuteMetaModifiers): Promise<ToolExecuteResponse$1>;
/**
* Fetches the list of all available tools in the Composio SDK.
*
* This method is mostly used by the CLI to get the list of tools.
* No filtering is done on the tools, the list is cached in the backend, no further optimization is required.
* @returns {Promise<ToolRetrieveEnumResponse>} The complete list of all available tools with their metadata
*
* @example
* ```typescript
* // Get all available tools as an enum
* const toolsEnum = await composio.tools.getToolsEnum();
* console.log(toolsEnum.items);
* ```
*/
getToolsEnum(): Promise<ToolRetrieveEnumResponse>;
/**
* Fetches the input parameters for a given tool.
*
* This method is used to get the input parameters for a tool before executing it.
*
* @param {string} slug - The ID of the tool to find input for
* @param {ToolGetInputParams} body - The parameters to be passed to the tool
* @returns {Promise<ToolGetInputResponse>} The input parameters schema for the specified tool
*
* @example
* ```typescript
* // Get input parameters for a specific tool
* const inputParams = await composio.tools.getInput('GITHUB_CREATE_ISSUE', {
* userId: 'default'
* });
* console.log(inputParams.schema);
* ```
*/
getInput(slug: string, body: ToolGetInputParams): Promise<ToolGetInputResponse>;
/**
* Proxies a custom request to a toolkit/integration.
*
* This method allows sending custom requests to a specific toolkit or integration
* when you need more flexibility than the standard tool execution methods provide.
*
* @param {ToolProxyParams} body - The parameters for the proxy request including toolkit slug and custom data
* @returns {Promise<ToolProxyResponse>} The response from the proxied request
*
* @example
* ```typescript
* // Send a custom request to a toolkit
* const response = await composio.tools.proxyExecute({
* toolkitSlug: 'github',
* userId: 'default',
* data: {
* endpoint: '/repos/owner/repo/issues',
* method: 'GET'
* }
* });
* console.log(response.data);
* ```
*/
proxyExecute(body: ToolProxyParams): Promise<ToolProxyResponse>;
/**
* Creates a custom tool that can be used within the Composio SDK.
*
* Custom tools allow you to extend the functionality of Composio with your own implementations
* while keeping a consistent interface for both built-in and custom tools.
*
* @param {CustomToolOptions} body - The configuration for the custom tool
* @returns {Promise<Tool>} The created custom tool
*
* @example
* ```typescript
* // creating a custom tool with a toolkit
* await composio.tools.createCustomTool({
* name: 'My Custom Tool',
* description: 'A custom tool that does something specific',
* slug: 'MY_CUSTOM_TOOL',
* userId: 'default',
* connectedAccountId: '123',
* toolkitSlug: 'github',
* inputParameters: z.object({
* param1: z.string().describe('First parameter'),
* }),
* execute: async (input, connectionConfig, executeToolRequest) => {
* // Custom logic here
* return { data: { result: 'Success!' } };
* }
* });
* ```
*
* @example
* ```typescript
* // creating a custom tool without a toolkit
* await composio.tools.createCustomTool({
* name: 'My Custom Tool',
* description: 'A custom tool that does something specific',
* slug: 'MY_CUSTOM_TOOL',
* inputParameters: z.object({
* param1: z.string().describe('First parameter'),
* }),
* execute: async (input) => {
* // Custom logic here
* return { data: { result: 'Success!' } };
* }
* });
*/
createCustomTool<T extends CustomToolInputParameter>(body: CustomToolOptions<T>): Promise<Tool>;
}
//#endregion
//#region src/types/toolkit.types.d.ts
/**
* Toolkit list params
*/
declare const ToolkitMangedByEnumSchema: z$1.ZodEnum<["all", "composio", "project"]>;
declare const ToolkitSortByEnumSchema: z$1.ZodEnum<["usage", "alphabetically"]>;
declare const ToolkitsListParamsSchema: z$1.ZodObject<{
category: z$1.ZodOptional<z$1.ZodString>;
managedBy: z$1.ZodOptional<z$1.ZodEnum<["all", "composio", "project"]>>;
sortBy: z$1.ZodOptional<z$1.ZodEnum<["usage", "alphabetically"]>>;
cursor: z$1.ZodOptional<z$1.ZodString>;
limit: z$1.ZodOptional<z$1.ZodNumber>;
}, "strip", z$1.ZodTypeAny, {
limit?: number | undefined;
cursor?: string | undefined;
category?: string | undefined;
managedBy?: "all" | "composio" | "project" | undefined;
sortBy?: "usage" | "alphabetically" | undefined;
}, {
limit?: number | undefined;
cursor?: string | undefined;
category?: string | undefined;
managedBy?: "all" | "composio" | "project" | undefined;
sortBy?: "usage" | "alphabetically" | undefined;
}>;
type ToolkitMangedByEnum = z$1.infer<typeof ToolkitMangedByEnumSchema>;
type ToolkitSortByEnum = z$1.infer<typeof ToolkitSortByEnumSchema>;
type ToolkitListParams = z$1.infer<typeof ToolkitsListParamsSchema>;
/**
* Toolkits response
*/
declare const ToolKitMetaSchema: z$1.ZodObject<{
categories: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
slug: z$1.ZodString;
name: z$1.ZodString;
}, "strip", z$1.ZodTypeAny, {
slug: string;
name: string;
}, {
slug: string;
name: string;
}>, "many">>;
appUrl: z$1.ZodOptional<z$1.ZodString>;
createdAt: z$1.ZodOptional<z$1.ZodString>;
description: z$1.ZodOptional<z$1.ZodString>;
logo: z$1.ZodOptional<z$1.ZodString>;
toolsCount: z$1.ZodOptional<z$1.ZodNumber>;
triggersCount: z$1.ZodOptional<z$1.ZodNumber>;
updatedAt: z$1.ZodOptional<z$1.ZodString>;
availableVersions: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString, "many">>;
}, "strip", z$1.ZodTypeAny, {
logo?: string | undefined;
description?: string | undefined;
availableVersions?: string[] | undefined;
createdAt?: string | undefined;
categories?: {
slug: string;
name: string;
}[] | undefined;
appUrl?: string | undefined;
toolsCount?: number | undefined;
triggersCount?: number | undefined;
updatedAt?: string | undefined;
}, {
logo?: string | undefined;
description?: string | undefined;
availableVersions?: string[] | undefined;
createdAt?: string | undefined;
categories?: {
slug: string;
name: string;
}[] | undefined;
appUrl?: string | undefined;
toolsCount?: number | undefined;
triggersCount?: number | undefined;
updatedAt?: string | undefined;
}>;
declare const ToolKitItemSchema: z$1.ZodObject<{
name: z$1.ZodString;
slug: z$1.ZodString;
meta: z$1.ZodObject<{
categories: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
slug: z$1.ZodString;
name: z$1.ZodString;
}, "strip", z$1.ZodTypeAny, {
slug: string;
name: string;
}, {
slug: string;
name: string;
}>, "many">>;
appUrl: z$1.ZodOptional<z$1.ZodString>;
createdAt: z$1.ZodOptional<z$1.ZodString>;
description: z$1.ZodOptional<z$1.ZodString>;
logo: z$1.ZodOptional<z$1.ZodString>;
toolsCount: z$1.ZodOptional<z$1.ZodNumber>;
triggersCount: z$1.ZodOptional<z$1.ZodNumber>;
updatedAt: z$1.ZodOptional<z$1.ZodString>;
availableVersions: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString, "many">>;
}, "strip", z$1.ZodTypeAny, {
logo?: string | undefined;
description?: string | undefined;
availableVersions?: string[] | undefined;
createdAt?: string | undefined;
categories?: {
slug: string;
name: string;
}[] | undefined;
appUrl?: string | undefined;
toolsCount?: number | undefined;
triggersCount?: number | undefined;
updatedAt?: string | undefined;
}, {
logo?: string | undefined;
description?: string | undefined;
availableVersions?: string[] | undefined;
createdAt?: string | undefined;
categories?: {
slug: string;
name: string;
}[] | undefined;
appUrl?: string | undefined;
toolsCount?: number | undefined;
triggersCount?: number | undefined;
updatedAt?: string | undefined;
}>;
isLocalToolkit: z$1.ZodBoolean;
authSchemes: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString, "many">>;
composioManagedAuthSchemes: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString, "many">>;
noAuth: z$1.ZodOptional<z$1.ZodBoolean>;
}, "strip", z$1.ZodTypeAny, {
slug: string;
name: string;
meta: {
logo?: string | undefined;
description?: string | undefined;
availableVersions?: string[] | undefined;
createdAt?: string | undefined;
categories?: {
slug: string;
name: string;
}[] | undefined;
appUrl?: string | undefined;
toolsCount?: number | undefined;
triggersCount?: number | undefined;
updatedAt?: string | undefined;
};
isLocalToolkit: boolean;
authSchemes?: string[] | undefined;
composioManagedAuthSchemes?: string[] | undefined;
noAuth?: boolean | undefined;
}, {
slug: string;
name: string;
meta: {
logo?: string | undefined;
description?: string | undefined;
availableVersions?: string[] | undefined;
createdAt?: string | undefined;
categories?: {
slug: string;
name: string;
}[] | undefined;
appUrl?: string | undefined;
toolsCount?: number | undefined;
triggersCount?: number | undefined;
updatedAt?: string | undefined;
};
isLocalToolkit: boolean;
authSchemes?: string[] | undefined;
composioManagedAuthSchemes?: string[] | undefined;
noAuth?: boolean | undefined;
}>;
declare const ToolKitListResponseSchema: z$1.ZodArray<z$1.ZodObject<{
name: z$1.ZodString;
slug: z$1.ZodString;
meta: z$1.ZodObject<{
categories: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
slug: z$1.ZodString;
name: z$1.ZodString;
}, "strip", z$1.ZodTypeAny, {
slug: string;
name: string;
}, {
slug: string;
name: string;
}>, "many">>;
appUrl: z$1.ZodOptional<z$1.ZodString>;
createdAt: z$1.ZodOptional<z$1.ZodString>;
description: z$1.ZodOptional<z$1.ZodString>;
logo: z$1.ZodOptional<z$1.ZodString>;
toolsCount: z$1.ZodOptional<z$1.ZodNumber>;
triggersCount: z$1.ZodOptional<z$1.ZodNumber>;
updatedAt: z$1.ZodOptional<z$1.ZodString>;
availableVersions: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString, "many">>;
}, "strip", z$1.ZodTypeAny, {
logo?: string | undefined;
description?: string | undefined;
availableVersions?: string[] | undefined;
createdAt?: string | undefined;
categories?: {
slug: string;
name: string;
}[] | undefined;
appUrl?: string | undefined;
toolsCount?: number | undefined;
triggersCount?: number | undefined;
updatedAt?: string | undefined;
}, {
logo?: string | undefined;
description?: string | undefined;
availableVersions?: string[] | undefined;
createdAt?: string | undefined;
categories?: {
slug: string;
name: string;
}[] | undefined;
appUrl?: string | undefined;
toolsCount?: number | undefined;
triggersCount?: number | undefined;
updatedAt?: string | undefined;
}>;
isLocalToolkit: z$1.ZodBoolean;
authSchemes: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString, "many">>;
composioManagedAuthSchemes: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString, "many">>;
noAuth: z$1.ZodOptional<z$1.ZodBoolean>;
}, "strip", z$1.ZodTypeAny, {
slug: string;
name: string;
meta: {
logo?: string | undefined;
description?: string | undefined;
availableVersions?: string[] | undefined;
createdAt?: string | undefined;
categories?: {
slug: string;
name: string;
}[] | undefined;
appUrl?: string | undefined;
toolsCount?: number | undefined;
triggersCount?: number | undefined;
updatedAt?: string | undefined;
};
isLocalToolkit: boolean;
authSchemes?: string[] | undefined;
composioManagedAuthSchemes?: string[] | undefined;
noAuth?: boolean | undefined;
}, {
slug: string;
name: string;
meta: {
logo?: string | undefined;
description?: string | undefined;
availableVersions?: string[] | undefined;
createdAt?: string | undefined;
categories?: {
slug: string;
name: string;
}[] | undefined;
appUrl?: string | undefined;
toolsCount?: number | undefined;
triggersCount?: number | undefined;
updatedAt?: string | undefined;
};
isLocalToolkit: boolean;
authSchemes?: string[] | undefined;
composioManagedAuthSchemes?: string[] | undefined;
noAuth?: boolean | undefined;
}>, "many">;
type ToolKitMeta = z$1.infer<typeof ToolKitMetaSchema>;
type ToolKitItem = z$1.infer<typeof ToolKitItemSchema>;
type ToolKitListResponse = z$1.infer<typeof ToolKitListResponseSchema>;
/**
* Toolkit retrieve response
*/
declare const ToolkitAuthFieldSchema: z$1.ZodObject<{
description: z$1.ZodString;
displayName: z$1.ZodString;
required: z$1.ZodBoolean;
name: z$1.ZodString;
type: z$1.ZodString;
default: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
}, "strip", z$1.ZodTypeAny, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}>;
declare const ToolkitAuthConfigDetailsSchema: z$1.ZodObject<{
name: z$1.ZodString;
mode: z$1.ZodString;
fields: z$1.ZodObject<{
authConfigCreation: z$1.ZodObject<{
optional: z$1.ZodArray<z$1.ZodObject<{
description: z$1.ZodString;
displayName: z$1.ZodString;
required: z$1.ZodBoolean;
name: z$1.ZodString;
type: z$1.ZodString;
default: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
}, "strip", z$1.ZodTypeAny, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}>, "many">;
required: z$1.ZodArray<z$1.ZodObject<{
description: z$1.ZodString;
displayName: z$1.ZodString;
required: z$1.ZodBoolean;
name: z$1.ZodString;
type: z$1.ZodString;
default: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
}, "strip", z$1.ZodTypeAny, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}>, "many">;
}, "strip", z$1.ZodTypeAny, {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
}, {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
}>;
connectedAccountInitiation: z$1.ZodObject<{
optional: z$1.ZodArray<z$1.ZodObject<{
description: z$1.ZodString;
displayName: z$1.ZodString;
required: z$1.ZodBoolean;
name: z$1.ZodString;
type: z$1.ZodString;
default: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
}, "strip", z$1.ZodTypeAny, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}>, "many">;
required: z$1.ZodArray<z$1.ZodObject<{
description: z$1.ZodString;
displayName: z$1.ZodString;
required: z$1.ZodBoolean;
name: z$1.ZodString;
type: z$1.ZodString;
default: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
}, "strip", z$1.ZodTypeAny, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}>, "many">;
}, "strip", z$1.ZodTypeAny, {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
}, {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
}>;
}, "strip", z$1.ZodTypeAny, {
authConfigCreation: {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
};
connectedAccountInitiation: {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
};
}, {
authConfigCreation: {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
};
connectedAccountInitiation: {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
};
}>;
proxy: z$1.ZodOptional<z$1.ZodObject<{
baseUrl: z$1.ZodOptional<z$1.ZodString>;
}, "strip", z$1.ZodTypeAny, {
baseUrl?: string | undefined;
}, {
baseUrl?: string | undefined;
}>>;
}, "strip", z$1.ZodTypeAny, {
name: string;
mode: string;
fields: {
authConfigCreation: {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
};
connectedAccountInitiation: {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
};
};
proxy?: {
baseUrl?: string | undefined;
} | undefined;
}, {
name: string;
mode: string;
fields: {
authConfigCreation: {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
};
connectedAccountInitiation: {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
};
};
proxy?: {
baseUrl?: string | undefined;
} | undefined;
}>;
declare const ToolkitRetrieveResponseSchema: z$1.ZodObject<{
name: z$1.ZodString;
slug: z$1.ZodString;
meta: z$1.ZodObject<{
categories: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
slug: z$1.ZodString;
name: z$1.ZodString;
}, "strip", z$1.ZodTypeAny, {
slug: string;
name: string;
}, {
slug: string;
name: string;
}>, "many">>;
appUrl: z$1.ZodOptional<z$1.ZodString>;
createdAt: z$1.ZodOptional<z$1.ZodString>;
description: z$1.ZodOptional<z$1.ZodString>;
logo: z$1.ZodOptional<z$1.ZodString>;
toolsCount: z$1.ZodOptional<z$1.ZodNumber>;
triggersCount: z$1.ZodOptional<z$1.ZodNumber>;
updatedAt: z$1.ZodOptional<z$1.ZodString>;
availableVersions: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString, "many">>;
}, "strip", z$1.ZodTypeAny, {
logo?: string | undefined;
description?: string | undefined;
availableVersions?: string[] | undefined;
createdAt?: string | undefined;
categories?: {
slug: string;
name: string;
}[] | undefined;
appUrl?: string | undefined;
toolsCount?: number | undefined;
triggersCount?: number | undefined;
updatedAt?: string | undefined;
}, {
logo?: string | undefined;
description?: string | undefined;
availableVersions?: string[] | undefined;
createdAt?: string | undefined;
categories?: {
slug: string;
name: string;
}[] | undefined;
appUrl?: string | undefined;
toolsCount?: number | undefined;
triggersCount?: number | undefined;
updatedAt?: string | undefined;
}>;
isLocalToolkit: z$1.ZodBoolean;
composioManagedAuthSchemes: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString, "many">>;
authConfigDetails: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
name: z$1.ZodString;
mode: z$1.ZodString;
fields: z$1.ZodObject<{
authConfigCreation: z$1.ZodObject<{
optional: z$1.ZodArray<z$1.ZodObject<{
description: z$1.ZodString;
displayName: z$1.ZodString;
required: z$1.ZodBoolean;
name: z$1.ZodString;
type: z$1.ZodString;
default: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
}, "strip", z$1.ZodTypeAny, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}>, "many">;
required: z$1.ZodArray<z$1.ZodObject<{
description: z$1.ZodString;
displayName: z$1.ZodString;
required: z$1.ZodBoolean;
name: z$1.ZodString;
type: z$1.ZodString;
default: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
}, "strip", z$1.ZodTypeAny, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}>, "many">;
}, "strip", z$1.ZodTypeAny, {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
}, {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
}>;
connectedAccountInitiation: z$1.ZodObject<{
optional: z$1.ZodArray<z$1.ZodObject<{
description: z$1.ZodString;
displayName: z$1.ZodString;
required: z$1.ZodBoolean;
name: z$1.ZodString;
type: z$1.ZodString;
default: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
}, "strip", z$1.ZodTypeAny, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}>, "many">;
required: z$1.ZodArray<z$1.ZodObject<{
description: z$1.ZodString;
displayName: z$1.ZodString;
required: z$1.ZodBoolean;
name: z$1.ZodString;
type: z$1.ZodString;
default: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
}, "strip", z$1.ZodTypeAny, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}, {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}>, "many">;
}, "strip", z$1.ZodTypeAny, {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
}, {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
}>;
}, "strip", z$1.ZodTypeAny, {
authConfigCreation: {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
};
connectedAccountInitiation: {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
};
}, {
authConfigCreation: {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
};
connectedAccountInitiation: {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
};
}>;
proxy: z$1.ZodOptional<z$1.ZodObject<{
baseUrl: z$1.ZodOptional<z$1.ZodString>;
}, "strip", z$1.ZodTypeAny, {
baseUrl?: string | undefined;
}, {
baseUrl?: string | undefined;
}>>;
}, "strip", z$1.ZodTypeAny, {
name: string;
mode: string;
fields: {
authConfigCreation: {
required: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
optional: {
name: string;
type: string;
description: string;
required: boolean;
displayName: string;
default?: string | null | undefined;
}[];
};
connectedAccountInitiation: {
requir