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.

Add userId in tool calls

haxzie7e99ce2ac074
diff --git a/examples/pre-processors/src/index.ts b/examples/pre-processors/src/index.ts
index 334724562..411152332 100644
--- a/examples/pre-processors/src/index.ts
+++ b/examples/pre-processors/src/index.ts
@@ -8,56 +8,19 @@ const composio = new Composio({
apiKey: process.env.COMPOSIO_API_KEY,
});
-const tools = await composio.getTools(
- {
- toolkitSlug: 'HACKERNEWS',
- },
- {}
-);
-// Local modifiers
-const tool = await composio.getToolBySlug('HACKERNEWS_GET_USER', {
- modifyToolSchema: (toolSlug, toolSchema) => {
- toolSchema.inputParameters = {};
- return toolSchema;
- },
-});
+const userId = 'default';
-// local modifiers, with tool as helper
-// @ts-ignore
-composio.toolset.handleToolCall({}, '', {
- beforeToolExecute: (toolSlug, toolExecuteParams) => {
- if (toolSlug === 'HACKERNEWS_GET_USER') {
- toolExecuteParams.arguments = {};
- }
- return toolExecuteParams;
+const tools = composio.tools.get(userId, 'HACKERNEWS_GET_USER', {
+ modifyToolSchema: (toolSlug, tool) => {
+ return {
+ ...tool,
+ description: 'This is a modified description',
+ };
},
});
-/**
- * Agentic toolset
- */
const vercelComposio = new Composio({
- apiKey: process.env.COMPOSIO_API_KEY,
toolset: new VercelToolset(),
});
-const verceltools = await vercelComposio.getTools(
- {
- toolkitSlug: 'HACKERNEWS',
- },
- {
- beforeToolExecute: (toolSlug, toolExecuteParams) => {
- if (toolSlug === 'HACKERNEWS_GET_USER') {
- toolExecuteParams.arguments = {};
- }
- return toolExecuteParams;
- },
- afterToolExecute: (toolSlug, toolExecuteResponse) => {
- if (toolSlug === 'HACKERNEWS_GET_USER') {
- toolExecuteResponse.data = { message: 'Hello, world!' };
- }
- return toolExecuteResponse;
- },
- }
-);
-console.log(verceltools);
+const vercelTools = vercelComposio.tools.get('default', {}, {});
diff --git a/packages/core/src/composio.ts b/packages/core/src/composio.ts
index ec1d58cb7..854b861ce 100644
--- a/packages/core/src/composio.ts
+++ b/packages/core/src/composio.ts
@@ -10,6 +10,7 @@ import { BaseTelemetryTransport } from './telemetry/TelemetryTransport';
import type { TelemetryMetadata } from './types/telemetry.types';
import type { ToolsetOptions } from './types/modifiers.types';
import type { ToolListParams } from './types/tool.types';
+import type { ToolOptions, AgenticToolOptions } from './types/modifiers.types';
import { getSDKConfig } from './utils/sdk';
import logger from './utils/logger';
import { IS_DEVELOPMENT_OR_CI } from './utils/constants';
@@ -58,7 +59,7 @@ export class Composio<TToolset extends BaseComposioToolset<unknown, unknown> = O
/**
* Core models for Composio.
*/
- tools: Tools;
+ tools: Tools<unknown, unknown, TToolset>;
toolkits: Toolkits;
triggers: Triggers;
toolset: TToolset;
@@ -123,7 +124,7 @@ export class Composio<TToolset extends BaseComposioToolset<unknown, unknown> = O
/**
* Initialize all the models with composio client.
*/
- this.tools = new Tools(this.client);
+ this.tools = new Tools(this.client, this.toolset);
this.toolkits = new Toolkits(this.client);
this.triggers = new Triggers(this.client);
this.authConfigs = new AuthConfigs(this.client);
@@ -200,10 +201,11 @@ export class Composio<TToolset extends BaseComposioToolset<unknown, unknown> = O
* @returns {Promise<ReturnType<TToolset['getTools']>>} The tools from the toolset.
*/
getTools<T extends TToolset>(
- params?: ToolListParams,
+ userId: string,
+ filters: ToolListParams,
modifiers?: ToolsetOptions<T>
): Promise<ReturnType<T['getTools']>> {
- return this.toolset.getTools(params, modifiers) as Promise<ReturnType<T['getTools']>>;
+ return this.tools.get(userId, filters, modifiers) as Promise<ReturnType<T['getTools']>>;
}
/**
@@ -213,9 +215,10 @@ export class Composio<TToolset extends BaseComposioToolset<unknown, unknown> = O
* @returns {Promise<ReturnType<TToolset['getToolBySlug']>>} The tool from the toolset.
*/
getToolBySlug<T extends TToolset>(
+ userId: string,
slug: string,
modifiers?: ToolsetOptions<T>
): Promise<ReturnType<T['getToolBySlug']>> {
- return this.toolset.getToolBySlug(slug, modifiers) as Promise<ReturnType<T['getToolBySlug']>>;
+ return this.tools.get(userId, slug, modifiers) as Promise<ReturnType<T['getToolBySlug']>>;
}
}
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index c2af4a778..52c040d43 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -1,7 +1,11 @@
// Core exports
export { Composio } from './composio';
export { ComposioToolset } from './toolset/ComposioToolset';
-export { BaseAgenticToolset, BaseNonAgenticToolset } from './toolset/BaseToolset';
+export {
+ BaseComposioToolset,
+ BaseAgenticToolset,
+ BaseNonAgenticToolset,
+} from './toolset/BaseToolset';
export { OpenAIToolset } from './toolset/OpenAIToolset';
export { BaseTelemetryTransport } from './telemetry/TelemetryTransport';
export { jsonSchemaToModel } from './utils/jsonSchema';
diff --git a/packages/core/src/models/Tools.ts b/packages/core/src/models/Tools.ts
index fc8813f3b..25962ce97 100644
--- a/packages/core/src/models/Tools.ts
+++ b/packages/core/src/models/Tools.ts
@@ -21,19 +21,32 @@ import {
} from '@composio/client/resources/tools';
import { CustomTools } from './CustomTools';
import { CustomToolOptions } from '../types/customTool.types';
-import { ExecuteToolModifiers, TransformToolSchemaModifier } from '../types/modifiers.types';
+import {
+ AgenticToolOptions,
+ ExecuteToolModifiers,
+ ToolOptions,
+ ToolsetOptions,
+ TransformToolSchemaModifier,
+} from '../types/modifiers.types';
+import { BaseComposioToolset } from '../toolset/BaseToolset';
/**
* This class is used to manage tools in the Composio SDK.
* It provides methods to list, get, and execute tools.
*/
-export class Tools {
+export class Tools<
+ TToolCollection,
+ TTool,
+ TToolset extends BaseComposioToolset<TToolCollection, TTool>,
+> {
private client: ComposioClient;
customTools: CustomTools;
+ private toolset: TToolset;
- constructor(client: ComposioClient) {
+ constructor(client: ComposioClient, toolset: TToolset) {
this.client = client;
this.customTools = new CustomTools(client);
+ this.toolset = toolset;
}
private transformToolCases(
@@ -61,7 +74,8 @@ export class Tools {
* This method fetches the tools from the Composio API and wraps them using the toolset.
* @returns {ToolList} List of tools
*/
- async getTools(
+ async getComposioTools(
+ userId: string,
query: ToolListParams = {},
modifier?: TransformToolSchemaModifier
): Promise<ToolList> {
@@ -106,7 +120,11 @@ export class Tools {
* @param slug The ID of the tool to be retrieved
* @returns {Promise<Tool>} The tool
*/
- async getToolBySlug(slug: string, modifier?: TransformToolSchemaModifier): Promise<Tool> {
+ async getComposioToolBySlug(
+ userId: string,
+ slug: string,
+ modifier?: TransformToolSchemaModifier
+ ): Promise<Tool> {
// check if the tool is a custom tool
const customTool = await this.customTools.getCustomToolBySlug(slug);
if (customTool) {
@@ -130,6 +148,24 @@ export class Tools {
return modifiedToool;
}
+ async get(userId: string, slug: string, options?: ToolsetOptions<TToolset>): Promise<TTool>;
+ async get(
+ userId: string,
+ filters: ToolListParams,
+ options?: ToolsetOptions<TToolset>
+ ): Promise<TToolCollection>;
+ async get(
+ userId: string,
+ arg1: ToolListParams | string,
+ options?: ToolsetOptions<TToolset>
+ ): Promise<TTool | TToolCollection> {
+ if (typeof arg1 === 'string') {
+ return this.toolset.getToolBySlug(userId, arg1, options);
+ } else {
+ return this.toolset.getTools(userId, arg1, options);
+ }
+ }
+
/**
* Exectes a given tool with the provided parameters.
*
@@ -162,6 +198,25 @@ export class Tools {
connectedAccountId: body.connectedAccountId,
});
} else {
+ // fetch connected accounts if doesn't exist
+ let connectedAccountId = body.connectedAccountId;
+ if (!connectedAccountId) {
+ const tool = await this.getComposioToolBySlug(body.userId, slug);
+ if (!tool.toolkit) {
+ throw new Error(`Unable to find toolkit for tool ${slug}`);
+ }
+ const connectedAccounts = await this.client.connectedAccounts.list({
+ user_id: body.userId,
+ toolkit_slug: tool.toolkit.slug,
+ });
+ // if no connected accounts, throw an error
+ if (connectedAccounts.items.length === 0) {
+ throw new Error('No connected accounts found');
+ }
+ // by default, use the first connected account
+ connectedAccountId = connectedAccounts.items[0].id;
+ }
+
result = await this.client.tools.execute(slug, {
allow_tracing: body.allowTracing,
connected_account_id: body.connectedAccountId,
diff --git a/packages/core/src/toolset/BaseToolset.ts b/packages/core/src/toolset/BaseToolset.ts
index 1bb5b51a1..655289a58 100644
--- a/packages/core/src/toolset/BaseToolset.ts
+++ b/packages/core/src/toolset/BaseToolset.ts
@@ -1,26 +1,23 @@
import type { Toolset } from '../types/toolset.types';
import type { Tool, ToolListParams } from '../types/tool.types';
import type { Composio } from '../composio';
-import { AgenticToolOptions, ToolOptions } from '../types/modifiers.types';
-
-/**
- * Base class for non-agentic toolsets that only support schema modifiers
- * This is used for toolsets that don't need to handle tool execution modifiers
- * eg: OpenAI, Anthropic, etc.
- */
-export abstract class BaseNonAgenticToolset<TToolCollection, TTool>
- implements Toolset<TTool, TToolCollection>
-{
+import { AgenticToolOptions, ExecuteToolModifiers, ToolOptions } from '../types/modifiers.types';
+
+// Type for backward compatibility and type constraints
+export abstract class BaseNonAgenticToolset<TToolCollection, TTool> {
protected composio: Composio<BaseComposioToolset<TToolCollection, TTool>> | undefined;
- protected DEFAULT_ENTITY_ID = 'default';
setComposio(composio: Composio<BaseComposioToolset<TToolCollection, TTool>>): void {
this.composio = composio;
}
- abstract getTools(params?: ToolListParams, modifiers?: ToolOptions): Promise<TToolCollection>;
+ abstract getTools(
+ userId: string,
+ params: ToolListParams,
+ options?: ToolOptions
+ ): Promise<TToolCollection>;
- abstract getToolBySlug(slug: string, modifiers?: ToolOptions): Promise<TTool>;
+ abstract getToolBySlug(userId: string, slug: string, options?: ToolOptions): Promise<TTool>;
abstract wrapTool(tool: Tool): TTool;
@@ -34,29 +31,26 @@ export abstract class BaseNonAgenticToolset<TToolCollection, TTool>
}
}
-/**
- * Base class for agentic toolsets that support full modifier capabilities
- * This is used for toolsets that need to handle tool execution modifiers
- * eg: Vercel, Langchain, etc.
- */
-export abstract class BaseAgenticToolset<TToolCollection, TTool>
- implements Toolset<TTool, TToolCollection>
-{
+export abstract class BaseAgenticToolset<TToolCollection, TTool> {
protected composio: Composio<BaseComposioToolset<TToolCollection, TTool>> | undefined;
- protected DEFAULT_ENTITY_ID = 'default';
setComposio(composio: Composio<BaseComposioToolset<TToolCollection, TTool>>): void {
this.composio = composio;
}
+ abstract getToolBySlug(
+ userId: string,
+ slug: string,
+ options?: AgenticToolOptions
+ ): Promise<TTool>;
+
abstract getTools(
- params?: ToolListParams,
- modifiers?: AgenticToolOptions
+ userId: string,
+ params: ToolListParams,
+ options?: AgenticToolOptions
): Promise<TToolCollection>;
- abstract getToolBySlug(slug: string, modifiers?: AgenticToolOptions): Promise<TTool>;
-
- abstract wrapTool(tool: Tool): TTool;
+ abstract wrapTool(userId: string, tool: Tool, modifers?: ExecuteToolModifiers): TTool;
protected getComposio(): Composio<BaseComposioToolset<TToolCollection, TTool>> {
if (!this.composio) {
@@ -68,7 +62,39 @@ export abstract class BaseAgenticToolset<TToolCollection, TTool>
}
}
-// Type for backward compatibility and type constraints
export type BaseComposioToolset<TToolCollection, TTool> =
| BaseNonAgenticToolset<TToolCollection, TTool>
| BaseAgenticToolset<TToolCollection, TTool>;
+
+// export abstract class BaseComposioToolset<
+// TToolCollection,
+// TTool,
+// TToolOptions extends ToolOptions | AgenticToolOptions,
+// > {
+// protected composio:
+// | Composio<BaseComposioToolset<TToolCollection, TTool, TToolOptions>>
+// | undefined;
+
+// setComposio(composio: Composio<BaseComposioToolset<TToolCollection, TTool, TToolOptions>>): void {
+// this.composio = composio;
+// }
+
+// abstract getTools(
+// userId: string,
+// params?: ToolListParams,
+// options?: TToolOptions
+// ): Promise<TToolCollection>;
+
+// abstract getToolBySlug(userId: string, slug: string, options?: TToolOptions): Promise<TTool>;
+
+// abstract wrapTool(userId: string, tool: Tool): TTool;
+
+// protected getComposio(): Composio<BaseComposioToolset<TToolCollection, TTool, TToolOptions>> {
+// if (!this.composio) {
+// throw new Error(
+// 'Client not initialized. Make sure the toolset is properly initialized with Composio.'
+// );
+// }
+// return this.composio;
+// }
+// }
diff --git a/packages/core/src/toolset/ComposioToolset.ts b/packages/core/src/toolset/ComposioToolset.ts
index f90e55e2e..71badf19f 100644
--- a/packages/core/src/toolset/ComposioToolset.ts
+++ b/packages/core/src/toolset/ComposioToolset.ts
@@ -1,6 +1,6 @@
import { ToolOptions } from '../types/modifiers.types';
import { Tool, ToolListParams } from '../types/tool.types';
-import { BaseNonAgenticToolset } from './BaseToolset';
+import { BaseComposioToolset, BaseNonAgenticToolset } from './BaseToolset';
/**
* This is a default toolset implementation for Composio.
@@ -23,14 +23,26 @@ export class ComposioToolset extends BaseNonAgenticToolset<Array<CustomTool>, Cu
return tool as CustomTool;
};
- async getTools(params?: ToolListParams): Promise<Array<CustomTool>> {
- const tools = await this.getComposio().tools.getTools(params);
- return tools?.map(tool => this.wrapTool(tool as Tool)) ?? [];
+ async getTools(
+ userId: string,
+ params?: ToolListParams,
+ options?: ToolOptions
+ ): Promise<Array<CustomTool>> {
+ const tools = await this.getComposio().tools.getComposioTools(
+ userId,
+ params,
+ options?.modifyToolSchema
+ );
+ return tools?.map(tool => this.wrapTool(tool)) ?? [];
}
- async getToolBySlug(slug: string, modifiers?: ToolOptions): Promise<CustomTool> {
- const tool = await this.getComposio().tools.getToolBySlug(slug, modifiers?.modifyToolSchema);
- return this.wrapTool(tool as Tool);
+ async getToolBySlug(userId: string, slug: string, modifiers?: ToolOptions): Promise<CustomTool> {
+ const tool = await this.getComposio().tools.getComposioToolBySlug(
+ userId,
+ slug,
+ modifiers?.modifyToolSchema
+ );
+ return this.wrapTool(tool);
}
async test() {}
diff --git a/packages/core/src/toolset/OpenAIToolset.ts b/packages/core/src/toolset/OpenAIToolset.ts
index 0dbc0bf10..d5a579ebc 100644
--- a/packages/core/src/toolset/OpenAIToolset.ts
+++ b/packages/core/src/toolset/OpenAIToolset.ts
@@ -9,7 +9,7 @@
*/
import { OpenAI } from 'openai';
import { Stream } from 'openai/streaming';
-import { BaseNonAgenticToolset } from './BaseToolset';
+import { BaseComposioToolset, BaseNonAgenticToolset } from './BaseToolset';
import { Tool, ToolExecuteParams, ToolListParams } from '../types/tool.types';
import logger from '../utils/logger';
import { ExecuteToolModifiers, ToolOptions } from '../types/modifiers.types';
@@ -41,13 +41,25 @@ export class OpenAIToolset extends BaseNonAgenticToolset<OpenAiToolCollection, O
* @param modifiers - Optional modifiers to transform tool schemas
* @returns The tools.
*/
- async getTools(params?: ToolListParams, modifiers?: ToolOptions): Promise<OpenAiToolCollection> {
- const tools = await this.getComposio()?.tools.getTools(params, modifiers?.modifyToolSchema);
- return tools?.map(tool => this.wrapTool(tool as Tool)) ?? [];
+ async getTools(
+ userId: string,
+ params?: ToolListParams,
+ modifiers?: ToolOptions
+ ): Promise<OpenAiToolCollection> {
+ const tools = await this.getComposio()?.tools.getComposioTools(
+ userId,
+ params,
+ modifiers?.modifyToolSchema
+ );
+ return tools?.map(tool => this.wrapTool(tool)) ?? [];
}
- async getToolBySlug(slug: string, modifiers?: ToolOptions): Promise<OpenAiTool> {
- const tool = await this.getComposio().tools.getToolBySlug(slug, modifiers?.modifyToolSchema);
+ async getToolBySlug(userId: string, slug: string, modifiers?: ToolOptions): Promise<OpenAiTool> {
+ const tool = await this.getComposio().tools.getComposioToolBySlug(
+ userId,
+ slug,
+ modifiers?.modifyToolSchema
+ );
return this.wrapTool(tool);
}
@@ -58,11 +70,14 @@ export class OpenAIToolset extends BaseNonAgenticToolset<OpenAiToolCollection, O
* @returns {Promise<string>} The result of the tool call.
*/
async executeToolCall(
+ userId: string,
tool: OpenAI.ChatCompletionMessageToolCall,
- userId?: string,
modifiers?: ExecuteToolModifiers
): Promise<string> {
- const toolSchema = await this.getComposio().tools.getToolBySlug(tool.function.name);
+ const toolSchema = await this.getComposio().tools.getComposioToolBySlug(
+ userId,
+ tool.function.name
+ );
const appSlug = toolSchema?.toolkit?.slug.toLowerCase();
if (!appSlug) {
throw new Error('App slug not found');
@@ -85,14 +100,14 @@ export class OpenAIToolset extends BaseNonAgenticToolset<OpenAiToolCollection, O
* @returns {Promise<string[]>} The results of the tool call.
*/
async handleToolCall(
+ userId: string,
chatCompletion: OpenAI.ChatCompletion,
- userId?: string,
modifiers?: ExecuteToolModifiers
) {
const outputs: string[] = [];
for (const message of chatCompletion.choices) {
if (message.message.tool_calls) {
- outputs.push(await this.executeToolCall(message.message.tool_calls[0], userId, modifiers));
+ outputs.push(await this.executeToolCall(userId, message.message.tool_calls[0], modifiers));
}
}
return outputs;
@@ -106,8 +121,8 @@ export class OpenAIToolset extends BaseNonAgenticToolset<OpenAiToolCollection, O
* @returns {Promise<OpenAI.Beta.Threads.Runs.RunSubmitToolOutputsParams.ToolOutput[]>} The tool outputs.
*/
async handleAssistantMessage(
+ userId: string,
run: OpenAI.Beta.Threads.Run,
- userId?: string,
modifiers?: ExecuteToolModifiers
) {
const tool_calls = run.required_action?.submit_tool_outputs?.tool_calls || [];
@@ -118,8 +133,8 @@ export class OpenAIToolset extends BaseNonAgenticToolset<OpenAiToolCollection, O
// Execute each tool call and get the response
const tool_response = await this.executeToolCall(
- tool_call as OpenAI.ChatCompletionMessageToolCall,
userId,
+ tool_call as OpenAI.ChatCompletionMessageToolCall,
modifiers
);
@@ -144,14 +159,13 @@ export class OpenAIToolset extends BaseNonAgenticToolset<OpenAiToolCollection, O
* @returns {AsyncGenerator<OpenAI.Beta.Assistants.AssistantStreamEvent, void, unknown>} The run stream.
*/
async *waitAndHandleAssistantStreamToolCalls(
+ userId: string,
client: OpenAI,
runStream: Stream<OpenAI.Beta.Assistants.AssistantStreamEvent>,
thread: OpenAI.Beta.Threads.Thread,
- userId?: string,
modifiers?: ExecuteToolModifiers
) {
// @TODO: Log the run stream
- const defaultUserId = this.getComposio()?.userId;
let runId = null;
// Start processing the runStream events
@@ -169,11 +183,7 @@ export class OpenAIToolset extends BaseNonAgenticToolset<OpenAiToolCollection, O
// Handle the 'requires_action' event
if (event.event === 'thread.run.requires_action') {
- const toolOutputs = await this.handleAssistantMessage(
- event.data,
- userId ?? defaultUserId,
- modifiers
- );
+ const toolOutputs = await this.handleAssistantMessage(userId, event.data, modifiers);
// Submit the tool outputs
await client.beta.threads.runs.submitToolOutputs(thread.id, runId, {
@@ -203,11 +213,7 @@ export class OpenAIToolset extends BaseNonAgenticToolset<OpenAiToolCollection, O
while (['queued', 'in_progress', 'requires_action'].includes(finalRun.status)) {
if (finalRun.status === 'requires_action') {
- const toolOutputs = await this.handleAssistantMessage(
- finalRun,
- userId ?? defaultUserId,
- modifiers
- );
+ const toolOutputs = await this.handleAssistantMessage(userId, finalRun, modifiers);
// Submit tool outputs
finalRun = await client.beta.threads.runs.submitToolOutputs(thread.id, runId, {
@@ -231,20 +237,15 @@ export class OpenAIToolset extends BaseNonAgenticToolset<OpenAiToolCollection, O
* @returns {Promise<OpenAI.Beta.Threads.Run>} The run object.
*/
async waitAndHandleAssistantToolCalls(
+ userId: string,
client: OpenAI,
run: OpenAI.Beta.Threads.Run,
thread: OpenAI.Beta.Threads.Thread,
- userId?: string,
modifiers?: ExecuteToolModifiers
) {
- const defaultUserId = this.getComposio()?.userId;
while (['queued', 'in_progress', 'requires_action'].includes(run.status)) {
// logger.debug(`Current run status: ${run.status}`);
- const tool_outputs = await this.handleAssistantMessage(
- run,
- userId ?? defaultUserId,
- modifiers
- );
+ const tool_outputs = await this.handleAssistantMessage(userId, run, modifiers);
if (run.status === 'requires_action') {
// logger.debug(
// `Submitting tool outputs for run ID: ${run.id} in thread ID: ${thread.id}`
diff --git a/packages/core/src/types/tool.types.ts b/packages/core/src/types/tool.types.ts
index 3d7786069..0b5209862 100644
--- a/packages/core/src/types/tool.types.ts
+++ b/packages/core/src/types/tool.types.ts
@@ -89,7 +89,7 @@ export const ToolExecuteParamsSchema = z.object({
connectedAccountId: z.string().optional(),
customAuthParams: CustomAuthParamsSchema.optional(),
arguments: z.record(z.string(), z.unknown()).optional(),
- userId: z.string().optional(),
+ userId: z.string(),
version: z.string().optional(),
text: z.string().optional(),
});
diff --git a/packages/toolsets/cloudflare/src/index.ts b/packages/toolsets/cloudflare/src/index.ts
index 5e714b680..f91c077c6 100644
--- a/packages/toolsets/cloudflare/src/index.ts
+++ b/packages/toolsets/cloudflare/src/index.ts
@@ -11,11 +11,11 @@
*/
import { AiTextGenerationToolInput } from '@cloudflare/workers-types';
import {
- BaseNonAgenticToolset,
Tool,
ToolListParams,
ExecuteToolModifiers,
ToolOptions,
+ BaseNonAgenticToolset,
} from '@composio/core';
type AiToolCollection = Record<string, AiTextGenerationToolInput>;
@@ -58,6 +58,7 @@ export class CloudflareToolset extends BaseNonAgenticToolset<
* @returns {Promise<Record<string, AiTextGenerationToolInput>>} The tools from the Cloudflare API.
*/
override async getTools(
+ userId: string,
query?: ToolListParams,
modifiers?: ToolOptions
): Promise<AiToolCollection> {
@@ -65,7 +66,11 @@ export class CloudflareToolset extends BaseNonAgenticToolset<
throw new Error('Client not set');
}
- const tools = await this.getComposio().tools.getTools(query, modifiers?.modifyToolSchema);
+ const tools = await this.getComposio().tools.getComposioTools(
+ userId,
+ query,
+ modifiers?.modifyToolSchema
+ );
return tools.reduce(
(tools, tool) => ({
...tools,
@@ -76,13 +81,18 @@ export class CloudflareToolset extends BaseNonAgenticToolset<
}
override async getToolBySlug(
+ userId: string,
slug: string,
modifiers?: ToolOptions
): Promise<AiTextGenerationToolInput> {
if (!this.getComposio()) {
throw new Error('Client not set');
}
- const tool = await this.getComposio().tools.getToolBySlug(slug, modifiers?.modifyToolSchema);
+ const tool = await this.getComposio().tools.getComposioToolBySlug(
+ userId,
+ slug,
+ modifiers?.modifyToolSchema
+ );
return this.wrapTool(tool);
}
@@ -93,15 +103,15 @@ export class CloudflareToolset extends BaseNonAgenticToolset<
* @returns The results of the tool call.
*/
async executeToolCall(
+ userId: string,
tool: { name: string; arguments: unknown },
- userId?: string,
modifiers?: ExecuteToolModifiers
): Promise<string> {
if (!this.getComposio()) {
throw new Error('Client not set');
}
- const toolSchema = await this.getComposio().tools.getToolBySlug(tool.name);
+ const toolSchema = await this.getComposio().tools.getComposioToolBySlug(userId, tool.name);
const appName = toolSchema?.toolkit?.name.toLowerCase();
if (!appName) {
throw new Error('App name not found');
@@ -111,7 +121,7 @@ export class CloudflareToolset extends BaseNonAgenticToolset<
toolSchema.slug,
{
arguments: args,
- userId: userId ?? this.DEFAULT_ENTITY_ID,
+ userId,
connectedAccountId: this.getComposio()?.getConnectedAccountId(appName),
},
modifiers
diff --git a/packages/toolsets/langchain/src/index.ts b/packages/toolsets/langchain/src/index.ts
index 0d8b06007..34868f7b0 100644
--- a/packages/toolsets/langchain/src/index.ts
+++ b/packages/toolsets/langchain/src/index.ts
@@ -29,7 +29,7 @@ export class LangchainToolset extends BaseAgenticToolset<
* @param tool - The tool to wrap.
* @returns The wrapped tool.
*/
- wrapTool(tool: Tool, modifiers?: AgenticToolOptions): DynamicStructuredTool {
+ wrapTool(userId: string, tool: Tool, modifiers?: AgenticToolOptions): DynamicStructuredTool {
const toolName = tool.slug;
const description = tool.description;
const appName = tool.toolkit?.name?.toLowerCase();
@@ -44,7 +44,7 @@ export class LangchainToolset extends BaseAgenticToolset<
toolName,
{
arguments: kwargs[0] as Record<string, unknown>,
- userId: this.getComposio().userId ?? this.DEFAULT_ENTITY_ID,
+ userId,
connectedAccountId: connectedAccountId,
},
modifiers
@@ -72,18 +72,28 @@ export class LangchainToolset extends BaseAgenticToolset<
* @returns The tools.
*/
override async getTools(
+ userId: string,
params?: ToolListParams,
modifiers?: AgenticToolOptions
): Promise<LangChainToolCollection> {
- const tools = await this.getComposio()?.tools.getTools(params, modifiers?.modifyToolSchema);
- return tools?.map(tool => this.wrapTool(tool, modifiers)) ?? [];
+ const tools = await this.getComposio()?.tools.getComposioTools(
+ userId,
+ params,
+ modifiers?.modifyToolSchema
+ );
+ return tools?.map(tool => this.wrapTool(userId, tool, modifiers)) ?? [];
}
override async getToolBySlug(
+ userId: string,
slug: string,
modifiers?: AgenticToolOptions
): Promise<DynamicStructuredTool> {
- const tool = await this.getComposio()?.tools.getToolBySlug(slug, modifiers?.modifyToolSchema);
- return this.wrapTool(tool as Tool, modifiers);
+ const tool = await this.getComposio()?.tools.getComposioToolBySlug(
+ userId,
+ slug,
+ modifiers?.modifyToolSchema
+ );
+ return this.wrapTool(userId, tool, modifiers);
}
}
diff --git a/packages/toolsets/vercel/src/index.ts b/packages/toolsets/vercel/src/index.ts
index 4e42f0066..169d86d1c 100644
--- a/packages/toolsets/vercel/src/index.ts
+++ b/packages/toolsets/vercel/src/index.ts
@@ -31,25 +31,34 @@ export class VercelToolset extends BaseAgenticToolset<VercelToolCollection, Verc
* @returns The tools.
*/
override async getTools(
+ userId: string,
params?: ToolListParams,
modifiers?: AgenticToolOptions
): Promise<VercelToolCollection> {
if (!this.getComposio()) {
throw new Error('Client not initialized');
}
- const tools = await this.getComposio().tools.getTools(params);
+ const tools = await this.getComposio().tools.getComposioTools(userId, params);
return tools.reduce(
(tools, tool) => ({
...tools,
- [tool.slug]: this.wrapTool(tool as ComposioTool, modifiers),
+ [tool.slug]: this.wrapTool(userId, tool, modifiers),
}),
{}
);
}
- override async getToolBySlug(slug: string, modifiers?: AgenticToolOptions): Promise<VercelTool> {
- const tool = await this.getComposio().tools.getToolBySlug(slug, modifiers?.modifyToolSchema);
- return this.wrapTool(tool as ComposioTool, modifiers);
+ override async getToolBySlug(
+ userId: string,
+ slug: string,
+ modifiers?: AgenticToolOptions
+ ): Promise<VercelTool> {
+ const tool = await this.getComposio().tools.getComposioToolBySlug(
+ userId,
+ slug,
+ modifiers?.modifyToolSchema
+ );
+ return this.wrapTool(userId, tool, modifiers);
}
/**
@@ -59,15 +68,15 @@ export class VercelToolset extends BaseAgenticToolset<VercelToolCollection, Verc
* @returns {Promise<string>} The result of the tool call.
*/
async executeToolCall(
+ userId: string,
tool: { name: string; arguments: unknown },
- userId?: string,
modifiers?: ExecuteToolModifiers
): Promise<string> {
if (!this.getComposio()) {
throw new Error('Client not initialized');
}
- const toolSchema = await this.getComposio().tools.getToolBySlug(tool.name);
+ const toolSchema = await this.getComposio().tools.getComposioToolBySlug(userId, tool.name);
const appName = toolSchema?.name.toLowerCase();
const args = typeof tool.arguments === 'string' ? JSON.parse(tool.arguments) : tool.arguments;
@@ -75,7 +84,7 @@ export class VercelToolset extends BaseAgenticToolset<VercelToolCollection, Verc
toolSchema.slug,
{
arguments: args,
- userId: userId ?? this.getComposio().userId,
+ userId: userId,
connectedAccountId: this.getComposio().getConnectedAccountId(appName),
},
modifiers
@@ -84,17 +93,21 @@ export class VercelToolset extends BaseAgenticToolset<VercelToolCollection, Verc
return JSON.stringify(results);
}
- wrapTool(composioTool: ComposioTool, modifiers?: ExecuteToolModifiers): VercelTool {
+ wrapTool(
+ userId: string,
+ composioTool: ComposioTool,
+ modifiers?: ExecuteToolModifiers
+ ): VercelTool {
return tool({
description: composioTool.description,
parameters: jsonSchema(composioTool.inputParameters ?? {}),
execute: async params => {
return await this.executeToolCall(
+ userId,
{
name: composioTool.slug,
arguments: JSON.stringify(params),
},
- this.getComposio()?.userId,
modifiers
);
},