Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
Mirrored from https://github.com/Camo67/composio.git
Synced Nov 21, 22:15 UTC
Add tool router preload support to TS SDK
Dhawal Upadhyay committed
Apr 29, 2026 at 02:41 UTC
88118e20f796fc8eaa9c91a0d446f36c16137786
11 files changed
+343
-163
.changeset/tool-router-preload-sdk.md
new
+5
@@ -0,0 +1,5 @@
1
+---
2
+"@composio/core": patch
3
+---
4
+
5
+Add Tool Router preload support in the TypeScript SDK and route session tool execution through the unified session execute endpoint.
ts/packages/core/src/lib/toolRouterParams.ts
+1
-1
@@ -128,7 +128,7 @@ export const transformToolRouterWorkbenchParams = (
128
129
export const transformToolRouterMultiAccountParams = (
130
params?: ToolRouterCreateSessionConfig['multiAccount']
131
-): Record<string, unknown> | undefined => {
131
+): SessionCreateParams.MultiAccount | undefined => {
132
if (!params) {
133
return undefined;
134
}
ts/packages/core/src/models/ToolRouter.ts
+20
-3
@@ -27,11 +27,13 @@ import {
27
SessionExperimental,
28
MCPServerType,
29
ToolRouterMCPServerConfig,
30
+ ToolRouterSessionMetadata,
31
} from '../types/toolRouter.types';
32
import { ToolRouterCreateSessionConfigSchema } from '../types/toolRouter.types';
33
import {
34
SessionCreateParams,
35
SessionCreateResponse,
36
+ SessionRetrieveResponse,
37
} from '@composio/client/resources/tool-router/session/session.mjs';
38
import {
39
transformToolRouterTagsParams,
@@ -49,6 +51,15 @@ import {
51
} from './CustomTool';
52
import type { CustomToolsMap } from '../types/customTool.types';
53
54
+function getSessionMetadata(session: SessionCreateResponse | SessionRetrieveResponse) {
55
+ const metadata: ToolRouterSessionMetadata = {
56
+ preload: session.config.preload,
57
+ configVersion: session.config_version,
58
+ warnings: 'warnings' in session ? (session.warnings ?? []) : [],
59
+ };
60
+ return metadata;
61
+}
62
+
63
export class ToolRouter<
64
TToolCollection,
65
TTool,
@@ -128,7 +139,7 @@ export class ToolRouter<
139
140
const multiAccountPayload = transformToolRouterMultiAccountParams(routerConfig.multiAccount);
141
131
- const payload: SessionCreateParams & { multi_account?: Record<string, unknown> } = {
142
+ const payload: SessionCreateParams = {
143
user_id: userId,
144
auth_configs: routerConfig.authConfigs,
145
connected_accounts: routerConfig.connectedAccounts,
@@ -140,6 +151,7 @@ export class ToolRouter<
151
),
152
workbench: transformToolRouterWorkbenchParams(routerConfig.workbench),
153
multi_account: multiAccountPayload,
154
+ preload: routerConfig.preload,
155
experimental: Object.keys(experimentalPayload).length > 0 ? experimentalPayload : undefined,
156
};
157
@@ -165,7 +177,8 @@ export class ToolRouter<
177
this.createMCPServerConfig(session.mcp),
178
{ assistivePrompt },
179
customToolsMap,
168
- userId
180
+ userId,
181
+ getSessionMetadata(session)
182
);
183
}
184
@@ -192,7 +205,11 @@ export class ToolRouter<
205
this.client,
206
this.config,
207
session.session_id,
195
- this.createMCPServerConfig(session.mcp)
208
+ this.createMCPServerConfig(session.mcp),
209
+ undefined,
210
+ undefined,
211
+ undefined,
212
+ getSessionMetadata(session)
213
);
214
}
215
}
ts/packages/core/src/models/ToolRouterSession.ts
+42
-16
@@ -12,6 +12,10 @@ import {
12
ToolRouterSessionExecuteResponse,
13
ToolRouterSessionExecuteResponseSchema,
14
ToolRouterSessionProxyExecuteResponse,
15
+ ToolRouterSessionExecuteOptions,
16
+ ToolRouterSessionMetadata,
17
+ ToolRouterSessionPreloadConfig,
18
+ ToolRouterSessionWarning,
19
} from '../types/toolRouter.types';
20
import {
21
transformSearchResponse,
@@ -33,8 +37,9 @@ import type {
37
RegisteredCustomTool,
38
RegisteredCustomToolkit,
39
} from '../types/customTool.types';
36
-import type { ToolExecuteResponse } from '../types/tool.types';
40
+import type { Tool, ToolExecuteResponse } from '../types/tool.types';
41
import type { SessionProxyExecuteParams } from '../types/toolRouter.types';
42
+import type { SessionExecuteParams } from '@composio/client/resources/tool-router/session/session.mjs';
43
import { SessionProxyExecuteParamsSchema } from '../types/toolRouter.types';
44
import { SessionContextImpl } from './SessionContext';
45
import { findCustomTool, executeCustomTool } from './customToolExecution';
@@ -50,6 +55,9 @@ export class ToolRouterSession<
55
public readonly sessionId: string;
56
public readonly mcp: ToolRouterMCPServerConfig;
57
public readonly experimental: SessionExperimental;
58
+ public readonly preload: ToolRouterSessionPreloadConfig;
59
+ public readonly configVersion?: number;
60
+ public readonly warnings: ToolRouterSessionWarning[];
61
62
/** Singleton session context — shared across all custom tool executions */
63
private readonly sessionContext?: SessionContext;
@@ -61,7 +69,8 @@ export class ToolRouterSession<
69
mcp: ToolRouterMCPServerConfig,
70
experimentalOverrides?: Pick<SessionExperimental, 'assistivePrompt'>,
71
private readonly customToolsMap?: CustomToolsMap,
64
- private readonly userId?: string
72
+ private readonly userId?: string,
73
+ metadata?: ToolRouterSessionMetadata
74
) {
75
if (customToolsMap && !userId) {
76
throw new Error('userId is required when custom tools are bound to a session.');
@@ -72,6 +81,9 @@ export class ToolRouterSession<
81
assistivePrompt: experimentalOverrides?.assistivePrompt,
82
files: new ToolRouterSessionFilesMount(client, sessionId),
83
};
84
+ this.preload = metadata?.preload ?? { tools: [] };
85
+ this.configVersion = metadata?.configVersion;
86
+ this.warnings = metadata?.warnings ?? [];
87
88
// Create singleton session context if custom tools are bound
89
if (customToolsMap && userId) {
@@ -90,10 +102,11 @@ export class ToolRouterSession<
102
*/
103
async tools(modifiers?: SessionMetaToolOptions): Promise<ReturnType<TProvider['wrapTools']>> {
104
const ToolsModel = new Tools<TToolCollection, TTool, TProvider>(this.client, this.config);
93
- const tools = await ToolsModel.getRawToolRouterMetaTools(
105
+ const tools = await ToolsModel.getRawToolRouterSessionTools(
106
this.sessionId,
107
modifiers?.modifySchema ? { modifySchema: modifiers.modifySchema } : undefined
108
);
109
+ const toolBySlug = new Map(tools.map(tool => [tool.slug.toUpperCase(), tool]));
110
111
if (this.hasCustomTools()) {
112
// Create an execute function that splits local/remote tools in COMPOSIO_MULTI_EXECUTE_TOOL
@@ -102,13 +115,13 @@ export class ToolRouterSession<
115
input: Record<string, unknown>
116
): Promise<ToolExecuteResponse> => {
117
if (toolSlug === COMPOSIO_MULTI_EXECUTE_TOOL) {
105
- return this.routeMultiExecute(input, ToolsModel, modifiers);
118
+ return this.routeMultiExecute(input, ToolsModel, tools, modifiers);
119
}
107
- // Non-multi-execute meta tools always go to backend
108
- return ToolsModel.executeMetaTool(
120
+ return ToolsModel.executeSessionTool(
121
toolSlug,
122
{ sessionId: this.sessionId, arguments: input },
111
- modifiers
123
+ modifiers,
124
+ toolBySlug.get(toolSlug.toUpperCase())
125
);
126
};
127
@@ -284,11 +297,14 @@ export class ToolRouterSession<
297
*
298
* @param toolSlug - The tool slug to execute
299
* @param arguments_ - Optional tool arguments
300
+ * @param options - Optional execution options
301
+ * @param options.account - Account identifier for direct app tool execution in multi-account sessions. Helper/meta tools either ignore this top-level field or define their own account-selection fields.
302
* @returns The tool execution result
303
*/
304
async execute(
305
toolSlug: string,
291
- arguments_?: Record<string, unknown>
306
+ arguments_?: Record<string, unknown>,
307
+ options?: ToolRouterSessionExecuteOptions
308
): Promise<ToolRouterSessionExecuteResponse> {
309
// Check if this is a local tool (by original or final slug)
310
const entry = findCustomTool(this.customToolsMap, toolSlug);
@@ -302,10 +318,15 @@ export class ToolRouterSession<
318
}
319
320
// Remote execution
305
- const response = await this.client.toolRouter.session.execute(this.sessionId, {
321
+ const executeParams: SessionExecuteParams = {
322
tool_slug: toolSlug,
323
arguments: arguments_ ?? {},
308
- });
324
+ };
325
+ if (options?.account) {
326
+ executeParams.account = options.account;
327
+ }
328
+
329
+ const response = await this.client.toolRouter.session.execute(this.sessionId, executeParams);
330
const transformed = transformExecuteResponse(response);
331
return ToolRouterSessionExecuteResponseSchema.parse(transformed);
332
}
@@ -375,15 +396,18 @@ export class ToolRouterSession<
396
private async routeMultiExecute(
397
input: Record<string, unknown>,
398
ToolsModel: Tools<TToolCollection, TTool, TProvider>,
399
+ tools: Tool[],
400
modifiers?: SessionMetaToolOptions
401
): Promise<ToolExecuteResponse> {
402
+ const multiExecuteTool = tools.find(tool => tool.slug === COMPOSIO_MULTI_EXECUTE_TOOL);
403
const toolItems = input.tools as unknown[];
404
if (!Array.isArray(toolItems) || toolItems.length === 0) {
405
// Fallback: send to backend as-is
383
- return ToolsModel.executeMetaTool(
406
+ return ToolsModel.executeSessionTool(
407
COMPOSIO_MULTI_EXECUTE_TOOL,
408
{ sessionId: this.sessionId, arguments: input },
386
- modifiers
409
+ modifiers,
410
+ multiExecuteTool
411
);
412
}
413
@@ -403,10 +427,11 @@ export class ToolRouterSession<
427
428
// All remote — just forward entire payload
429
if (localItems.length === 0) {
406
- return ToolsModel.executeMetaTool(
430
+ return ToolsModel.executeSessionTool(
431
COMPOSIO_MULTI_EXECUTE_TOOL,
432
{ sessionId: this.sessionId, arguments: input },
409
- modifiers
433
+ modifiers,
434
+ multiExecuteTool
435
);
436
}
437
@@ -422,10 +447,11 @@ export class ToolRouterSession<
447
if (remoteIndices.length > 0) {
448
const remoteToolItems = remoteIndices.map(i => toolItems[i]);
449
const remoteInput = { ...input, tools: remoteToolItems };
425
- remotePromise = ToolsModel.executeMetaTool(
450
+ remotePromise = ToolsModel.executeSessionTool(
451
COMPOSIO_MULTI_EXECUTE_TOOL,
452
{ sessionId: this.sessionId, arguments: remoteInput },
428
- modifiers
453
+ modifiers,
454
+ multiExecuteTool
455
);
456
}
457
ts/packages/core/src/models/Tools.ts
+33
-27
@@ -15,6 +15,7 @@ import {
15
ToolkitVersionParam,
16
SchemaModifierOptions,
17
ToolRetrievalOptions,
18
+ ToolExecuteMetaParams,
19
ToolExecuteMetaParamsSchema,
20
} from '../types/tool.types';
21
import {
@@ -53,8 +54,7 @@ import { telemetry } from '../telemetry/Telemetry';
54
import { ComposioConfig } from '../composio';
55
import { getToolkitVersion } from '../utils/toolkitVersion';
56
import { handleToolExecutionError } from '../errors/ToolErrors';
56
-import { ToolExecuteMetaParams } from '../types/tool.types';
57
-import { SessionExecuteMetaParams } from '@composio/client/resources/tool-router.mjs';
57
+import { SessionExecuteParams } from '@composio/client/resources/tool-router.mjs';
58
import { CONFIG_DEFAULTS } from '../utils/config-defaults';
59
import { resolveEffectiveUploadAllowlist } from '../utils/fileDirs';
60
import { schemaHasFileUploadable } from '../utils/modifiers/FileToolModifier.utils.neutral';
@@ -467,22 +467,22 @@ export class Tools<
467
}
468
469
/**
470
- * Fetches the meta tools for a tool router session.
471
- * This method fetches the meta tools from the Composio API and transforms them to the expected format.
472
- * It provides access to the underlying meta tool data without provider-specific wrapping.
470
+ * Fetches tools exposed by a tool router session.
471
+ * This includes helper/meta tools plus any tools preloaded into the session.
472
+ * It provides access to the underlying tool data without provider-specific wrapping.
473
*
474
- * @param sessionId {string} The session id to get the meta tools for
474
+ * @param sessionId {string} The session id to get tools for
475
* @param options {SchemaModifierOptions} Optional configuration for tool retrieval
476
* @param {TransformToolSchemaModifier} [options.modifySchema] - Function to transform the tool schema
477
- * @returns {Promise<ToolList>} The list of meta tools
477
+ * @returns {Promise<ToolList>} The list of session tools
478
*
479
* @example
480
* ```typescript
481
- * const metaTools = await composio.tools.getRawToolRouterMetaTools('session_123');
482
- * console.log(metaTools);
481
+ * const sessionTools = await composio.tools.getRawToolRouterSessionTools('session_123');
482
+ * console.log(sessionTools);
483
* ```
484
*/
485
- async getRawToolRouterMetaTools(
485
+ async getRawToolRouterSessionTools(
486
sessionId: string,
487
options?: SchemaModifierOptions
488
): Promise<ToolList> {
@@ -759,7 +759,7 @@ export class Tools<
759
tools: Tool[],
760
modifiers?: SessionExecuteMetaModifiers
761
): Tool[] {
762
- const executeToolFn = this.createExecuteToolFnForToolRouter(sessionId, modifiers);
762
+ const executeToolFn = this.createExecuteToolFnForToolRouter(sessionId, tools, modifiers);
763
return this.provider.wrapTools(tools, executeToolFn) as Tool[];
764
}
765
@@ -800,19 +800,22 @@ export class Tools<
800
*/
801
private createExecuteToolFnForToolRouter(
802
sessionId: string,
803
+ tools: Tool[],
804
modifiers?: SessionExecuteMetaModifiers
805
): ExecuteToolFn {
806
+ const toolBySlug = new Map(tools.map(tool => [tool.slug.toUpperCase(), tool]));
807
const executeToolFn = async (
808
toolSlug: string,
809
input: Record<string, unknown>
810
): Promise<ToolExecuteResponse> => {
809
- return await this.executeMetaTool(
811
+ return await this.executeSessionTool(
812
toolSlug,
813
{
814
sessionId,
815
arguments: input,
816
},
815
- modifiers
817
+ modifiers,
818
+ toolBySlug.get(toolSlug.toUpperCase())
819
);
820
};
821
return executeToolFn;
@@ -997,44 +1000,47 @@ export class Tools<
1000
}
1001
1002
/**
1000
- * Executes a composio meta tool based on tool router session
1003
+ * Executes a tool based on a tool router session.
1004
*
1005
* @param {string} toolSlug - The slug of the tool to execute
1006
* @param {ToolExecuteMetaParams} body - The execution parameters
1007
* @param {string} body.sessionId - The session id to execute the tool for
1008
* @param {Record<string, unknown>} body.arguments - The input to pass to the tool
1009
* @param {SessionExecuteMetaModifiers} modifiers - The modifiers to apply to the tool
1010
+ * @param {Tool} tool - Optional tool schema used to resolve toolkit metadata for modifiers
1011
* @returns {Promise<ToolExecuteResponse>} The response from the tool execution
1012
*/
1009
- async executeMetaTool(
1013
+ async executeSessionTool(
1014
toolSlug: string,
1015
body: ToolExecuteMetaParams,
1012
- modifiers?: SessionExecuteMetaModifiers
1016
+ modifiers?: SessionExecuteMetaModifiers,
1017
+ tool?: Tool
1018
): Promise<ToolExecuteResponse> {
1014
- const executeMetaParams = ToolExecuteMetaParamsSchema.safeParse(body);
1015
- if (!executeMetaParams.success) {
1016
- throw new ValidationError('Invalid tool execute meta parameters', {
1017
- cause: executeMetaParams.error,
1019
+ const executeParams = ToolExecuteMetaParamsSchema.safeParse(body);
1020
+ if (!executeParams.success) {
1021
+ throw new ValidationError('Invalid tool execute session parameters', {
1022
+ cause: executeParams.error,
1023
});
1024
}
1025
1026
// Apply beforeExecute modifier if provided
1027
let modifiedParams = body.arguments ?? {};
1028
+ const toolkitSlug = tool?.toolkit?.slug ?? 'composio';
1029
if (modifiers?.beforeExecute) {
1030
modifiedParams = await modifiers.beforeExecute({
1031
toolSlug,
1026
- toolkitSlug: 'composio',
1032
+ toolkitSlug,
1033
sessionId: body.sessionId,
1034
params: modifiedParams,
1035
});
1036
}
1037
1032
- // Execute the meta tool
1033
- const response = await this.client.toolRouter.session.executeMeta(body.sessionId, {
1034
- // assert this because backend might keep adding more tool slugs
1035
- slug: toolSlug as SessionExecuteMetaParams['slug'],
1038
+ const executePayload: SessionExecuteParams = {
1039
+ tool_slug: toolSlug,
1040
arguments: modifiedParams,
1037
- });
1041
+ };
1042
+
1043
+ const response = await this.client.toolRouter.session.execute(body.sessionId, executePayload);
1044
1045
// Prepare the result
1046
let result: ToolExecuteResponse = {
@@ -1048,7 +1054,7 @@ export class Tools<
1054
if (modifiers?.afterExecute) {
1055
result = await modifiers.afterExecute({
1056
toolSlug,
1051
- toolkitSlug: 'composio',
1057
+ toolkitSlug,
1058
sessionId: body.sessionId,
1059
result,
1060
});
ts/packages/core/src/types/modifiers.types.ts
+27
-27
@@ -424,29 +424,29 @@ export type ExecuteToolModifiers = {
424
} & BeforeFileUploadHook;
425
426
/**
427
- * Type alias for meta tool execution arguments.
428
- * Represents the arguments passed to a meta tool during execution.
427
+ * Type alias for session tool execution arguments.
428
+ * Represents the arguments passed to a tool during session execution.
429
* This is derived from ToolExecuteMetaParams but guaranteed to be non-null.
430
*/
431
export type MetaToolArguments = NonNullable<ToolExecuteMetaParams['arguments']>;
432
433
/**
434
- * Modifier for altering the meta tool execute parameters before execution in a session context.
434
+ * Modifier for altering tool execute parameters before execution in a session context.
435
*
436
- * This function is specifically designed for meta tools executed within a tool router session,
437
- * allowing you to intercept and modify the parameters before execution. Meta tools are
438
- * grouped under the 'composio' toolkit slug for organizational purposes.
436
+ * This function is specifically designed for tools executed within a tool router session,
437
+ * allowing you to intercept and modify the parameters before execution. Helper tools use
438
+ * the 'composio' toolkit slug; preloaded app tools use their own toolkit slug when available.
439
*
440
- * @param {string} toolSlug - The slug identifier of the meta tool being executed
441
- * @param {string} toolkitSlug - The toolkit slug (always 'composio' for meta tools)
440
+ * @param {string} toolSlug - The slug identifier of the tool being executed
441
+ * @param {string} toolkitSlug - The toolkit slug for this tool
442
* @param {string} sessionId - The session ID for the tool router context
443
- * @param {MetaToolArguments} params - The parameters being passed to the meta tool
443
+ * @param {MetaToolArguments} params - The parameters being passed to the tool
444
* @returns {MetaToolArguments} The modified parameters
445
*
446
* @example
447
* ```typescript
448
* const beforeExecuteMeta = ({ toolSlug, toolkitSlug, sessionId, params }) => {
449
- * console.log(`Executing ${toolkitSlug} meta tool ${toolSlug} in session ${sessionId}`);
449
+ * console.log(`Executing ${toolkitSlug} tool ${toolSlug} in session ${sessionId}`);
450
*
451
* // Add or modify parameters
452
* return {
@@ -464,14 +464,14 @@ export type beforeExecuteMetaModifier = (context: {
464
}) => Promise<MetaToolArguments> | MetaToolArguments;
465
466
/**
467
- * Modifier for altering the meta tool execution response after execution completes in a session context.
467
+ * Modifier for altering a tool execution response after execution completes in a session context.
468
*
469
- * This function is specifically designed for meta tools executed within a tool router session,
469
+ * This function is specifically designed for tools executed within a tool router session,
470
* allowing you to intercept and modify the response after execution. This is useful for
471
* session-specific transformations, logging, or error handling.
472
*
473
- * @param {string} toolSlug - The slug identifier of the meta tool that was executed
474
- * @param {string} toolkitSlug - The toolkit slug (always 'composio' for meta tools)
473
+ * @param {string} toolSlug - The slug identifier of the tool that was executed
474
+ * @param {string} toolkitSlug - The toolkit slug for this tool
475
* @param {string} sessionId - The session ID for the tool router context
476
* @param {ToolExecuteResponse} result - The original execution response
477
* @returns {ToolExecuteResponse} The modified execution response
@@ -480,7 +480,7 @@ export type beforeExecuteMetaModifier = (context: {
480
* ```typescript
481
* const afterExecuteMeta = ({ toolSlug, toolkitSlug, sessionId, result }) => {
482
* // Log session-specific execution
483
- * console.log(`${toolkitSlug} meta tool ${toolSlug} completed in session ${sessionId}`);
483
+ * console.log(`${toolkitSlug} tool ${toolSlug} completed in session ${sessionId}`);
484
*
485
* if (!result.successful) {
486
* console.error(`Session ${sessionId} error:`, result.error);
@@ -498,15 +498,15 @@ export type afterExecuteMetaModifier = (context: {
498
}) => Promise<ToolExecuteResponse> | ToolExecuteResponse;
499
500
/**
501
- * Modifiers specifically for meta tool execution within a session context.
501
+ * Modifiers specifically for tool execution within a session context.
502
*
503
- * These modifiers are designed for tool router session-based meta tool execution,
504
- * providing hooks to intercept and modify both the request and response of meta tools.
505
- * Meta tools are grouped under the 'composio' toolkit for organizational consistency.
503
+ * These modifiers are designed for tool router session-based execution,
504
+ * providing hooks to intercept and modify both the request and response of helper
505
+ * tools and preloaded app tools.
506
*
507
* @example
508
* ```typescript
509
- * const metaModifiers: SessionExecuteMetaModifiers = {
509
+ * const sessionModifiers: SessionExecuteMetaModifiers = {
510
* beforeExecute: ({ toolSlug, toolkitSlug, sessionId, params }) => {
511
* // Add session tracking
512
* console.log(`Executing ${toolkitSlug}/${toolSlug}`);
@@ -536,13 +536,13 @@ export type afterExecuteMetaModifier = (context: {
536
*/
537
export type SessionExecuteMetaModifiers = {
538
/**
539
- * Function to intercept and modify meta tool execution parameters before the tool is executed.
539
+ * Function to intercept and modify session tool execution parameters before the tool is executed.
540
* This allows customizing the request based on session-specific needs.
541
*/
542
beforeExecute?: beforeExecuteMetaModifier;
543
544
/**
545
- * Function to intercept and modify meta tool execution responses after the tool has executed.
545
+ * Function to intercept and modify session tool execution responses after the tool has executed.
546
* This allows transforming the response or implementing custom session-specific handling.
547
*/
548
afterExecute?: afterExecuteMetaModifier;
@@ -587,15 +587,15 @@ export type SessionExecuteMetaModifiers = {
587
export type AgenticToolOptions = ToolOptions & ExecuteToolModifiers;
588
589
/**
590
- * Options for session-based meta tool configuration in tool router contexts.
590
+ * Options for session-based tool configuration in tool router contexts.
591
*
592
* These options combine schema modification capabilities with session-specific execution
593
* behavior customization, providing control over both the definition and execution
594
- * of meta tools within a tool router session. Meta tools are grouped under the 'composio' toolkit.
594
+ * of tools within a tool router session.
595
*
596
* @example
597
* ```typescript
598
- * // Configure meta tools with schema and session-specific execution modifications
598
+ * // Configure session tools with schema and session-specific execution modifications
599
* const sessionTools = await toolRouter.getTools(sessionId, {
600
* modifySchema: (context) => {
601
* return {
@@ -604,7 +604,7 @@ export type AgenticToolOptions = ToolOptions & ExecuteToolModifiers;
604
* };
605
* },
606
*
607
- * // Intercept before meta tool execution
607
+ * // Intercept before session tool execution
608
* beforeExecute: ({ toolSlug, toolkitSlug, sessionId, params }) => {
609
* // Add session tracking
610
* console.log(`Executing ${toolkitSlug}/${toolSlug}`);
@@ -614,7 +614,7 @@ export type AgenticToolOptions = ToolOptions & ExecuteToolModifiers;
614
* };
615
* },
616
*
617
- * // Transform after meta tool execution
617
+ * // Transform after session tool execution
618
* afterExecute: ({ toolSlug, toolkitSlug, sessionId, result }) => {
619
* // Log session results
620
* if (!result.successful) {
ts/packages/core/src/types/toolRouter.types.ts
+44
-1
@@ -3,6 +3,7 @@ import type { BaseComposioProvider } from '../provider/BaseProvider';
3
import { SessionMetaToolOptions } from './modifiers.types';
4
import { ConnectionRequest } from './connectionRequest.types';
5
import type { ToolRouterSessionFilesMount } from '../models/ToolRouterSessionFileMount';
6
+import type { SessionCreateResponse } from '@composio/client/resources/tool-router/session/session.mjs';
7
import type {
8
CustomTool,
9
CustomToolkit,
@@ -254,6 +255,19 @@ export const ToolRouterCreateSessionConfigSchema = z
255
.optional()
256
.describe('Multi-account configuration for this session'),
257
258
+ preload: z
259
+ .object({
260
+ tools: z
261
+ .array(z.string())
262
+ .optional()
263
+ .describe(
264
+ 'Tool slugs to preload into session.tools() and the MCP tool list. The backend validates slugs against the session filters.'
265
+ ),
266
+ })
267
+ .strict()
268
+ .optional()
269
+ .describe('Preload configuration for tools that should be exposed without search.'),
270
+
271
experimental: z
272
.object({
273
assistivePrompt: z
@@ -305,6 +319,8 @@ export const ToolRouterCreateSessionConfigSchema = z
319
* @param {boolean} [multiAccount.enable] - When true, enables multi-account mode. Falls back to org/project-level config when not set.
320
* @param {number} [multiAccount.maxAccountsPerToolkit] - Max connected accounts per toolkit (2-10, default 5)
321
* @param {boolean} [multiAccount.requireExplicitSelection] - When true, require explicit account selection when multiple accounts are connected
322
+ * @param {object} [preload] - Tools to preload into session.tools() and the MCP tool list
323
+ * @param {string[]} [preload.tools] - Tool slugs to preload. Server-side validation ensures they exist and are allowed by the session filters.
324
*/
325
export type ToolRouterCreateSessionConfig = z.infer<typeof ToolRouterCreateSessionConfigSchema>;
326
@@ -506,9 +522,30 @@ export type ToolRouterSessionSearchFn = (params: {
522
523
export type ToolRouterSessionExecuteFn = (
524
toolSlug: string,
509
- arguments_?: Record<string, unknown>
525
+ arguments_?: Record<string, unknown>,
526
+ options?: ToolRouterSessionExecuteOptions
527
) => Promise<ToolRouterSessionExecuteResponse>;
528
529
+export interface ToolRouterSessionExecuteOptions {
530
+ /**
531
+ * Account identifier for direct app tool execution in multi-account sessions.
532
+ * Meta/helper tools either ignore this top-level field or define
533
+ * their own account-selection fields, for example
534
+ * COMPOSIO_MULTI_EXECUTE_TOOL.tools[].account.
535
+ */
536
+ account?: string;
537
+}
538
+
539
+export type ToolRouterSessionPreloadConfig = SessionCreateResponse.Config.Preload;
540
+
541
+export type ToolRouterSessionWarning = SessionCreateResponse.Warning;
542
+
543
+export interface ToolRouterSessionMetadata {
544
+ preload?: ToolRouterSessionPreloadConfig;
545
+ configVersion?: number;
546
+ warnings?: ToolRouterSessionWarning[];
547
+}
548
+
549
export const SessionProxyExecuteParamsSchema = z.object({
550
/** The toolkit whose connected account to use for auth (e.g. 'gmail', 'github') */
551
toolkit: z.string(),
@@ -543,6 +580,12 @@ export interface Session<
580
> {
581
sessionId: string;
582
mcp: ToolRouterMCPServerConfig;
583
+ /** Stored preload configuration for this session. */
584
+ preload: ToolRouterSessionPreloadConfig;
585
+ /** Server-side config version when returned by the API. */
586
+ configVersion?: number;
587
+ /** Non-blocking session creation warnings returned by the API. */
588
+ warnings: ToolRouterSessionWarning[];
589
tools: ToolRouterToolsFn<TToolCollection, TTool, TProvider>;
590
authorize: ToolRouterAuthorizeFn;
591
toolkits: ToolRouterToolkitsFn;
ts/packages/core/test/models/customToolRouting.test.ts
+21
-16
@@ -16,12 +16,12 @@ vi.mock('../../src/telemetry/Telemetry', () => ({
16
// Mock Tools class
17
vi.mock('../../src/models/Tools', () => ({
18
Tools: vi.fn().mockImplementation(() => ({
19
- getRawToolRouterMetaTools: vi.fn().mockResolvedValue([
19
+ getRawToolRouterSessionTools: vi.fn().mockResolvedValue([
20
{ slug: 'COMPOSIO_SEARCH_TOOLS', name: 'Search Tools' },
21
{ slug: 'COMPOSIO_MULTI_EXECUTE_TOOL', name: 'Multi Execute' },
22
]),
23
wrapToolsForToolRouter: vi.fn().mockReturnValue('wrapped-tools'),
24
- executeMetaTool: vi.fn().mockResolvedValue({
24
+ executeSessionTool: vi.fn().mockResolvedValue({
25
data: { remote: true },
26
error: null,
27
successful: true,
@@ -38,13 +38,17 @@ const createMockClient = () => ({
38
session: {
39
create: vi.fn().mockResolvedValue({
40
session_id: 'sess_123',
41
+ config: {
42
+ preload: { tools: [] },
43
+ user_id: 'user_1',
44
+ },
45
+ config_version: 1,
46
mcp: { type: 'http', url: 'https://mcp.example.com/sess_123' },
47
tool_router_tools: [],
48
}),
49
retrieve: vi.fn(),
50
link: vi.fn(),
51
toolkits: vi.fn(),
47
- executeMeta: vi.fn(),
52
search: vi.fn(),
53
proxyExecute: vi.fn().mockResolvedValue({
54
status: 200,
@@ -504,7 +508,7 @@ describe('ToolRouterSession execution routing', () => {
508
expect(localExecute).not.toHaveBeenCalled();
509
});
510
507
- it('should route non-MULTI_EXECUTE meta tools to backend', async () => {
511
+ it('should route non-MULTI_EXECUTE session tools to backend', async () => {
512
const provider = new MockProvider();
513
captureExecuteFn(provider);
514
const session = createSessionWithProvider(mockClient, provider, [customToolHandle]);
@@ -578,7 +582,7 @@ describe('ToolRouterSession execution routing', () => {
582
it('should append local results to remote results array', async () => {
583
const { executeFn, toolsInstance } = await setupMultiExecute(mockClient, [customToolHandle]);
584
581
- toolsInstance.executeMetaTool.mockResolvedValueOnce(
585
+ toolsInstance.executeSessionTool.mockResolvedValueOnce(
586
backendResponse([{ tool_slug: 'GMAIL_SEND_EMAIL', data: { sent: true } }])
587
);
588
@@ -635,7 +639,7 @@ describe('ToolRouterSession execution routing', () => {
639
sessionToolHandle,
640
]);
641
638
- toolsInstance.executeMetaTool.mockResolvedValueOnce(
642
+ toolsInstance.executeSessionTool.mockResolvedValueOnce(
643
backendResponse([
644
{ tool_slug: 'GMAIL_SEND_EMAIL', data: { sent: true } },
645
{ tool_slug: 'SLACK_POST_MESSAGE', data: { ts: '999' } },
@@ -659,7 +663,7 @@ describe('ToolRouterSession execution routing', () => {
663
expect(findResult(results, 'GMAIL_SEND_EMAIL')).toBeDefined();
664
expect(findResult(results, 'SLACK_POST_MESSAGE')).toBeDefined();
665
662
- const backendTools = toolsInstance.executeMetaTool.mock.calls[0][1].arguments.tools;
666
+ const backendTools = toolsInstance.executeSessionTool.mock.calls[0][1].arguments.tools;
667
expect(backendTools).toHaveLength(2);
668
expect(backendTools.map((t: any) => t.tool_slug)).toEqual([
669
'GMAIL_SEND_EMAIL',
@@ -674,7 +678,7 @@ describe('ToolRouterSession execution routing', () => {
678
it('should recompute remote counters when local results are merged', async () => {
679
const { executeFn, toolsInstance } = await setupMultiExecute(mockClient, [customToolHandle]);
680
677
- toolsInstance.executeMetaTool.mockResolvedValueOnce(
681
+ toolsInstance.executeSessionTool.mockResolvedValueOnce(
682
backendResponse([{ tool_slug: 'GMAIL_SEND_EMAIL', data: { sent: true } }])
683
);
684
@@ -694,7 +698,7 @@ describe('ToolRouterSession execution routing', () => {
698
it('should handle remote null data without crashing', async () => {
699
const { executeFn, toolsInstance } = await setupMultiExecute(mockClient, [customToolHandle]);
700
697
- toolsInstance.executeMetaTool.mockResolvedValueOnce({
701
+ toolsInstance.executeSessionTool.mockResolvedValueOnce({
702
data: null,
703
error: null,
704
successful: true,
@@ -728,7 +732,7 @@ describe('ToolRouterSession execution routing', () => {
732
throwingHandle,
733
]);
734
731
- toolsInstance.executeMetaTool.mockResolvedValueOnce(
735
+ toolsInstance.executeSessionTool.mockResolvedValueOnce(
736
backendResponse([
737
{ tool_slug: 'GMAIL_SEND_EMAIL', data: { sent: true } },
738
{
@@ -770,7 +774,7 @@ describe('ToolRouterSession execution routing', () => {
774
it('should preserve batch-level remote errors when no per-tool remote results exist', async () => {
775
const { executeFn, toolsInstance } = await setupMultiExecute(mockClient, [customToolHandle]);
776
773
- toolsInstance.executeMetaTool.mockResolvedValueOnce({
777
+ toolsInstance.executeSessionTool.mockResolvedValueOnce({
778
data: null,
779
error: 'Remote batch failed before per-tool results were produced',
780
successful: false,
@@ -796,20 +800,21 @@ describe('ToolRouterSession execution routing', () => {
800
sync_response_to_workbench: false,
801
});
802
799
- expect(toolsInstance.executeMetaTool).toHaveBeenCalledWith(
803
+ expect(toolsInstance.executeSessionTool).toHaveBeenCalledWith(
804
'COMPOSIO_MULTI_EXECUTE_TOOL',
805
expect.objectContaining({
806
sessionId: 'sess_123',
807
arguments: expect.objectContaining({ tools: [] }),
808
}),
805
- undefined
809
+ undefined,
810
+ expect.objectContaining({ slug: 'COMPOSIO_MULTI_EXECUTE_TOOL' })
811
);
812
});
813
814
it('should handle non-object items in tools array gracefully', async () => {
815
const { executeFn, toolsInstance } = await setupMultiExecute(mockClient, [customToolHandle]);
816
812
- toolsInstance.executeMetaTool.mockResolvedValueOnce(backendResponse([]));
817
+ toolsInstance.executeSessionTool.mockResolvedValueOnce(backendResponse([]));
818
819
const result = await executeFn('COMPOSIO_MULTI_EXECUTE_TOOL', {
820
tools: [
@@ -851,7 +856,7 @@ describe('ToolRouterSession execution routing', () => {
856
const toolsInstance = (Tools as any).mock.results[(Tools as any).mock.results.length - 1]
857
.value;
858
854
- toolsInstance.executeMetaTool.mockImplementation(async () => {
859
+ toolsInstance.executeSessionTool.mockImplementation(async () => {
860
callOrder.push('remote-start');
861
await new Promise(r => setTimeout(r, 50));
862
callOrder.push('remote-end');
@@ -906,7 +911,7 @@ describe('ToolRouterSession execution routing', () => {
911
const latestToolsInstance = (Tools as any).mock.results[
912
(Tools as any).mock.results.length - 1
913
].value;
909
- latestToolsInstance.executeMetaTool.mockResolvedValueOnce({
914
+ latestToolsInstance.executeSessionTool.mockResolvedValueOnce({
915
data: {
916
results: [
917
{
ts/packages/core/test/models/toolRouter.test.ts
+105
-11
@@ -18,7 +18,7 @@ vi.mock('../../src/models/Tools', () => {
18
return {
19
Tools: vi.fn().mockImplementation(() => ({
20
getRawComposioTools: vi.fn().mockResolvedValue([{ slug: 'GMAIL_FETCH_EMAILS' }]),
21
- getRawToolRouterMetaTools: vi.fn().mockResolvedValue([{ slug: 'COMPOSIO_SEARCH_TOOLS' }]),
21
+ getRawToolRouterSessionTools: vi.fn().mockResolvedValue([{ slug: 'COMPOSIO_SEARCH_TOOLS' }]),
22
wrapToolsForToolRouter: vi.fn().mockReturnValue('mocked-wrapped-tools'),
23
})),
24
};
@@ -34,7 +34,6 @@ const createMockClient = () => ({
34
retrieve: vi.fn(),
35
link: vi.fn(),
36
toolkits: vi.fn(),
37
- executeMeta: vi.fn(),
37
search: vi.fn(),
38
execute: vi.fn(),
39
},
@@ -54,6 +53,10 @@ const mockSessionCreateResponse = {
53
url: 'https://mcp.example.com/session_123',
54
},
55
tool_router_tools: ['GMAIL_FETCH_EMAILS', 'SLACK_SEND_MESSAGE', 'GITHUB_CREATE_ISSUE'],
56
+ config: {
57
+ preload: { tools: [] },
58
+ },
59
+ config_version: 1,
60
};
61
62
const mockLinkResponse = {
@@ -76,7 +79,9 @@ const mockSessionRetrieveResponse = {
79
manage_connections: {
80
enable: true,
81
},
82
+ preload: { tools: ['GMAIL_FETCH_EMAILS'] },
83
},
84
+ config_version: 7,
85
};
86
87
const mockToolkitsResponse = {
@@ -221,6 +226,40 @@ describe('ToolRouter', () => {
226
});
227
228
expect(session.sessionId).toBe('session_123');
229
+ expect(session.preload.tools).toEqual([]);
230
+ expect(session.configVersion).toBe(1);
231
+ });
232
+
233
+ it('should create a session with preloaded tools', async () => {
234
+ mockClient.toolRouter.session.create.mockResolvedValueOnce({
235
+ ...mockSessionCreateResponse,
236
+ config: {
237
+ preload: { tools: ['GMAIL_FETCH_EMAILS'] },
238
+ },
239
+ config_version: 2,
240
+ });
241
+
242
+ const session = await toolRouter.create(userId, {
243
+ toolkits: ['gmail'],
244
+ preload: { tools: ['GMAIL_FETCH_EMAILS'] },
245
+ });
246
+
247
+ expect(mockClient.toolRouter.session.create).toHaveBeenCalledWith({
248
+ user_id: userId,
249
+ toolkits: {
250
+ enable: ['gmail'],
251
+ },
252
+ auth_configs: undefined,
253
+ connected_accounts: undefined,
254
+ tools: undefined,
255
+ tags: undefined,
256
+ manage_connections: createExpectedManageConnections(),
257
+ workbench: undefined,
258
+ preload: { tools: ['GMAIL_FETCH_EMAILS'] },
259
+ });
260
+
261
+ expect(session.preload.tools).toEqual(['GMAIL_FETCH_EMAILS']);
262
+ expect(session.configVersion).toBe(2);
263
});
264
265
it('should create a session with user ID only and verify MCP type transformation', async () => {
@@ -2083,6 +2122,20 @@ describe('ToolRouter', () => {
2122
arguments: {},
2123
});
2124
});
2125
+
2126
+ it('should pass account option to session execute', async () => {
2127
+ mockClient.toolRouter.session.create.mockResolvedValueOnce(mockSessionCreateResponse);
2128
+ mockClient.toolRouter.session.execute.mockResolvedValueOnce(mockExecuteResponse);
2129
+
2130
+ const session = await toolRouter.create(userId);
2131
+ await session.execute('GMAIL_SEND_EMAIL', { to: 'user@example.com' }, { account: 'work' });
2132
+
2133
+ expect(mockClient.toolRouter.session.execute).toHaveBeenCalledWith(sessionId, {
2134
+ tool_slug: 'GMAIL_SEND_EMAIL',
2135
+ arguments: { to: 'user@example.com' },
2136
+ account: 'work',
2137
+ });
2138
+ });
2139
});
2140
2141
describe('tools function', () => {
@@ -2094,7 +2147,9 @@ describe('ToolRouter', () => {
2147
vi.clearAllMocks();
2148
(Tools as any).mockImplementation(() => ({
2149
getRawComposioTools: vi.fn().mockResolvedValue([{ slug: 'GMAIL_FETCH_EMAILS' }]),
2097
- getRawToolRouterMetaTools: vi.fn().mockResolvedValue([{ slug: 'COMPOSIO_SEARCH_TOOLS' }]),
2150
+ getRawToolRouterSessionTools: vi
2151
+ .fn()
2152
+ .mockResolvedValue([{ slug: 'COMPOSIO_SEARCH_TOOLS' }]),
2153
wrapToolsForToolRouter: vi.fn().mockReturnValue('mocked-wrapped-tools'),
2154
}));
2155
});
@@ -2111,7 +2166,7 @@ describe('ToolRouter', () => {
2166
});
2167
2168
const toolsInstance = (Tools as any).mock.results[0].value;
2114
- expect(toolsInstance.getRawToolRouterMetaTools).toHaveBeenCalledWith(sessionId, undefined);
2169
+ expect(toolsInstance.getRawToolRouterSessionTools).toHaveBeenCalledWith(sessionId, undefined);
2170
expect(toolsInstance.wrapToolsForToolRouter).toHaveBeenCalledWith(
2171
sessionId,
2172
[{ slug: 'COMPOSIO_SEARCH_TOOLS' }],
@@ -2136,7 +2191,7 @@ describe('ToolRouter', () => {
2191
const tools = await session.tools(modifiers);
2192
2193
const toolsInstance = (Tools as any).mock.results[0].value;
2139
- expect(toolsInstance.getRawToolRouterMetaTools).toHaveBeenCalledWith(sessionId, {
2194
+ expect(toolsInstance.getRawToolRouterSessionTools).toHaveBeenCalledWith(sessionId, {
2195
modifySchema: modifiers.modifySchema,
2196
});
2197
expect(toolsInstance.wrapToolsForToolRouter).toHaveBeenCalledWith(
@@ -2148,12 +2203,49 @@ describe('ToolRouter', () => {
2203
expect(tools).toBe('mocked-wrapped-tools');
2204
});
2205
2206
+ it('should include preloaded tools returned by the session tools endpoint', async () => {
2207
+ mockClient.toolRouter.session.create.mockResolvedValueOnce({
2208
+ ...mockSessionCreateResponse,
2209
+ config: {
2210
+ preload: { tools: ['GMAIL_FETCH_EMAILS'] },
2211
+ },
2212
+ });
2213
+
2214
+ (Tools as any).mockImplementation(() => ({
2215
+ getRawComposioTools: vi.fn().mockResolvedValue([{ slug: 'GMAIL_FETCH_EMAILS' }]),
2216
+ getRawToolRouterSessionTools: vi
2217
+ .fn()
2218
+ .mockResolvedValue([
2219
+ { slug: 'COMPOSIO_SEARCH_TOOLS' },
2220
+ { slug: 'GMAIL_FETCH_EMAILS', toolkit: { slug: 'gmail', name: 'Gmail' } },
2221
+ ]),
2222
+ wrapToolsForToolRouter: vi.fn().mockReturnValue('mocked-wrapped-tools'),
2223
+ }));
2224
+
2225
+ const session = await toolRouter.create(userId, {
2226
+ toolkits: ['gmail'],
2227
+ preload: { tools: ['GMAIL_FETCH_EMAILS'] },
2228
+ });
2229
+ const tools = await session.tools();
2230
+
2231
+ const toolsInstance = (Tools as any).mock.results[0].value;
2232
+ expect(toolsInstance.wrapToolsForToolRouter).toHaveBeenCalledWith(
2233
+ sessionId,
2234
+ [
2235
+ { slug: 'COMPOSIO_SEARCH_TOOLS' },
2236
+ { slug: 'GMAIL_FETCH_EMAILS', toolkit: { slug: 'gmail', name: 'Gmail' } },
2237
+ ],
2238
+ undefined
2239
+ );
2240
+ expect(tools).toBe('mocked-wrapped-tools');
2241
+ });
2242
+
2243
it('should handle tools fetching errors', async () => {
2244
mockClient.toolRouter.session.create.mockResolvedValueOnce(mockSessionCreateResponse);
2245
2246
(Tools as any).mockImplementation(() => ({
2247
getRawComposioTools: vi.fn().mockRejectedValue(new Error('Failed to fetch tools')),
2156
- getRawToolRouterMetaTools: vi.fn().mockRejectedValue(new Error('Failed to fetch tools')),
2248
+ getRawToolRouterSessionTools: vi.fn().mockRejectedValue(new Error('Failed to fetch tools')),
2249
wrapToolsForToolRouter: vi.fn().mockReturnValue('mocked-wrapped-tools'),
2250
}));
2251
@@ -2178,7 +2270,7 @@ describe('ToolRouter', () => {
2270
expect(Tools).toHaveBeenCalledTimes(2);
2271
2272
const firstToolsInstance = (Tools as any).mock.results[0].value;
2181
- expect(firstToolsInstance.getRawToolRouterMetaTools).toHaveBeenCalledWith(sessionId, {
2273
+ expect(firstToolsInstance.getRawToolRouterSessionTools).toHaveBeenCalledWith(sessionId, {
2274
modifySchema: modifier1.modifySchema,
2275
});
2276
expect(firstToolsInstance.wrapToolsForToolRouter).toHaveBeenCalledWith(
@@ -2188,7 +2280,7 @@ describe('ToolRouter', () => {
2280
);
2281
2282
const secondToolsInstance = (Tools as any).mock.results[1].value;
2191
- expect(secondToolsInstance.getRawToolRouterMetaTools).toHaveBeenCalledWith(sessionId, {
2283
+ expect(secondToolsInstance.getRawToolRouterSessionTools).toHaveBeenCalledWith(sessionId, {
2284
modifySchema: modifier2.modifySchema,
2285
});
2286
expect(secondToolsInstance.wrapToolsForToolRouter).toHaveBeenCalledWith(
@@ -2215,7 +2307,7 @@ describe('ToolRouter', () => {
2307
apiKey: 'test-api-key',
2308
});
2309
const toolsInstance = (Tools as any).mock.results[0].value;
2218
- expect(toolsInstance.getRawToolRouterMetaTools).toHaveBeenCalledWith(
2310
+ expect(toolsInstance.getRawToolRouterSessionTools).toHaveBeenCalledWith(
2311
'custom_session_123',
2312
undefined
2313
);
@@ -2243,7 +2335,7 @@ describe('ToolRouter', () => {
2335
apiKey: 'test-api-key',
2336
});
2337
const toolsInstance = (Tools as any).mock.results[0].value;
2246
- expect(toolsInstance.getRawToolRouterMetaTools).toHaveBeenCalledWith(
2338
+ expect(toolsInstance.getRawToolRouterSessionTools).toHaveBeenCalledWith(
2339
'empty_session_123',
2340
undefined
2341
);
@@ -2371,6 +2463,8 @@ describe('ToolRouter', () => {
2463
expect(session).toHaveProperty('tools');
2464
expect(session).toHaveProperty('authorize');
2465
expect(session).toHaveProperty('toolkits');
2466
+ expect(session.preload.tools).toEqual(['GMAIL_FETCH_EMAILS']);
2467
+ expect(session.configVersion).toBe(7);
2468
});
2469
2470
it('should return a session with correct session ID', async () => {
@@ -2402,7 +2496,7 @@ describe('ToolRouter', () => {
2496
expect(Tools).toHaveBeenCalled();
2497
2498
const toolsInstance = (Tools as any).mock.results[0].value;
2405
- expect(toolsInstance.getRawToolRouterMetaTools).toHaveBeenCalledWith(sessionId, undefined);
2499
+ expect(toolsInstance.getRawToolRouterSessionTools).toHaveBeenCalledWith(sessionId, undefined);
2500
expect(toolsInstance.wrapToolsForToolRouter).toHaveBeenCalledWith(
2501
sessionId,
2502
[{ slug: 'COMPOSIO_SEARCH_TOOLS' }],
ts/packages/core/test/tools/tools.test.ts
+44
-60
@@ -1019,7 +1019,7 @@ describe('Tools', () => {
1019
describe('Tool Router Execution', () => {
1020
const sessionId = 'test-session-123';
1021
1022
- describe('executeMetaTool', () => {
1022
+ describe('executeSessionTool', () => {
1023
it('should execute a tool via tool router session', async () => {
1024
const toolSlug = 'COMPOSIO_TOOL';
1025
const body = {
@@ -1027,21 +1027,16 @@ describe('Tools', () => {
1027
arguments: { query: 'test' },
1028
};
1029
1030
- const getRawComposioToolBySlugSpy = vi.spyOn(context.tools, 'getRawComposioToolBySlug');
1031
- getRawComposioToolBySlugSpy.mockResolvedValueOnce(
1032
- toolMocks.transformedTool as unknown as Tool
1033
- );
1034
-
1035
- mockClient.toolRouter.session.executeMeta.mockResolvedValueOnce({
1030
+ mockClient.toolRouter.session.execute.mockResolvedValueOnce({
1031
data: { results: true },
1032
error: null,
1033
log_id: '123',
1034
});
1035
1041
- const result = await context.tools.executeMetaTool(toolSlug, body);
1036
+ const result = await context.tools.executeSessionTool(toolSlug, body);
1037
1043
- expect(mockClient.toolRouter.session.executeMeta).toHaveBeenCalledWith(sessionId, {
1044
- slug: toolSlug,
1038
+ expect(mockClient.toolRouter.session.execute).toHaveBeenCalledWith(sessionId, {
1039
+ tool_slug: toolSlug,
1040
arguments: body.arguments,
1041
});
1042
expect(result).toEqual({
@@ -1058,17 +1053,17 @@ describe('Tools', () => {
1053
arguments: { query: 'test' },
1054
} as any;
1055
1061
- await expect(context.tools.executeMetaTool('COMPOSIO_TOOL', invalidBody)).rejects.toThrow(
1062
- 'Invalid tool execute meta parameters'
1063
- );
1056
+ await expect(
1057
+ context.tools.executeSessionTool('COMPOSIO_TOOL', invalidBody)
1058
+ ).rejects.toThrow('Invalid tool execute session parameters');
1059
});
1060
1061
it('should throw error if tool is not found', async () => {
1062
const apiError = new Error('Tool not found');
1068
- mockClient.toolRouter.session.executeMeta.mockRejectedValueOnce(apiError);
1063
+ mockClient.toolRouter.session.execute.mockRejectedValueOnce(apiError);
1064
1065
await expect(
1071
- context.tools.executeMetaTool('NONEXISTENT_TOOL', {
1066
+ context.tools.executeSessionTool('NONEXISTENT_TOOL', {
1067
sessionId,
1068
arguments: { query: 'test' },
1069
})
@@ -1087,10 +1082,7 @@ describe('Tools', () => {
1082
toolkit: { slug: 'test-toolkit', name: 'Test Toolkit' },
1083
};
1084
1090
- const getRawComposioToolBySlugSpy = vi.spyOn(context.tools, 'getRawComposioToolBySlug');
1091
- getRawComposioToolBySlugSpy.mockResolvedValueOnce(toolWithToolkit as unknown as Tool);
1092
-
1093
- mockClient.toolRouter.session.executeMeta.mockResolvedValueOnce({
1085
+ mockClient.toolRouter.session.execute.mockResolvedValueOnce({
1086
data: { results: true },
1087
error: null,
1088
log_id: '123',
@@ -1101,17 +1093,22 @@ describe('Tools', () => {
1093
query: 'modified',
1094
}));
1095
1104
- await context.tools.executeMetaTool(toolSlug, body, { beforeExecute });
1096
+ await context.tools.executeSessionTool(
1097
+ toolSlug,
1098
+ body,
1099
+ { beforeExecute },
1100
+ toolWithToolkit as unknown as Tool
1101
+ );
1102
1103
expect(beforeExecute).toHaveBeenCalledWith({
1104
toolSlug,
1108
- toolkitSlug: 'composio',
1105
+ toolkitSlug: 'test-toolkit',
1106
sessionId,
1107
params: { query: 'original' },
1108
});
1109
1113
- expect(mockClient.toolRouter.session.executeMeta).toHaveBeenCalledWith(sessionId, {
1114
- slug: toolSlug,
1110
+ expect(mockClient.toolRouter.session.execute).toHaveBeenCalledWith(sessionId, {
1111
+ tool_slug: toolSlug,
1112
arguments: { query: 'modified' },
1113
});
1114
});
@@ -1128,10 +1125,7 @@ describe('Tools', () => {
1125
toolkit: { slug: 'test-toolkit', name: 'Test Toolkit' },
1126
};
1127
1131
- const getRawComposioToolBySlugSpy = vi.spyOn(context.tools, 'getRawComposioToolBySlug');
1132
- getRawComposioToolBySlugSpy.mockResolvedValueOnce(toolWithToolkit as unknown as Tool);
1133
-
1134
- mockClient.toolRouter.session.executeMeta.mockResolvedValueOnce({
1128
+ mockClient.toolRouter.session.execute.mockResolvedValueOnce({
1129
data: { results: true },
1130
error: null,
1131
log_id: '123',
@@ -1142,11 +1136,16 @@ describe('Tools', () => {
1136
data: { results: 'modified result' },
1137
}));
1138
1145
- const result = await context.tools.executeMetaTool(toolSlug, body, { afterExecute });
1139
+ const result = await context.tools.executeSessionTool(
1140
+ toolSlug,
1141
+ body,
1142
+ { afterExecute },
1143
+ toolWithToolkit as unknown as Tool
1144
+ );
1145
1146
expect(afterExecute).toHaveBeenCalledWith({
1147
toolSlug,
1149
- toolkitSlug: 'composio',
1148
+ toolkitSlug: 'test-toolkit',
1149
sessionId,
1150
result: {
1151
data: { results: true },
@@ -1166,18 +1165,13 @@ describe('Tools', () => {
1165
arguments: { query: 'test' },
1166
};
1167
1169
- const getRawComposioToolBySlugSpy = vi.spyOn(context.tools, 'getRawComposioToolBySlug');
1170
- getRawComposioToolBySlugSpy.mockResolvedValueOnce(
1171
- toolMocks.transformedTool as unknown as Tool
1172
- );
1173
-
1174
- mockClient.toolRouter.session.executeMeta.mockResolvedValueOnce({
1168
+ mockClient.toolRouter.session.execute.mockResolvedValueOnce({
1169
data: null,
1170
error: 'Something went wrong',
1171
log_id: '456',
1172
});
1173
1180
- const result = await context.tools.executeMetaTool(toolSlug, body);
1174
+ const result = await context.tools.executeSessionTool(toolSlug, body);
1175
1176
expect(result).toEqual({
1177
data: null,
@@ -1199,10 +1193,7 @@ describe('Tools', () => {
1193
toolkit: undefined,
1194
};
1195
1202
- const getRawComposioToolBySlugSpy = vi.spyOn(context.tools, 'getRawComposioToolBySlug');
1203
- getRawComposioToolBySlugSpy.mockResolvedValueOnce(toolWithoutToolkit as unknown as Tool);
1204
-
1205
- mockClient.toolRouter.session.executeMeta.mockResolvedValueOnce({
1196
+ mockClient.toolRouter.session.execute.mockResolvedValueOnce({
1197
data: { results: true },
1198
error: null,
1199
log_id: '123',
@@ -1210,7 +1201,12 @@ describe('Tools', () => {
1201
1202
const beforeExecute = vi.fn().mockImplementation(({ params }) => params);
1203
1213
- await context.tools.executeMetaTool(toolSlug, body, { beforeExecute });
1204
+ await context.tools.executeSessionTool(
1205
+ toolSlug,
1206
+ body,
1207
+ { beforeExecute },
1208
+ toolWithoutToolkit as unknown as Tool
1209
+ );
1210
1211
expect(beforeExecute).toHaveBeenCalledWith({
1212
toolSlug,
@@ -1233,7 +1229,7 @@ describe('Tools', () => {
1229
expect(result).toBe('wrapped-tools');
1230
});
1231
1236
- it('should create execute function that calls executeMetaTool', async () => {
1232
+ it('should create execute function that calls executeSessionTool', async () => {
1233
const tools = [toolMocks.transformedTool as unknown as Tool];
1234
1235
let capturedExecuteFn: (toolSlug: string, input: Record<string, unknown>) => Promise<any>;
@@ -1245,13 +1241,7 @@ describe('Tools', () => {
1241
1242
context.tools.wrapToolsForToolRouter(sessionId, tools);
1243
1248
- // Setup mocks for execution
1249
- const getRawComposioToolBySlugSpy = vi.spyOn(context.tools, 'getRawComposioToolBySlug');
1250
- getRawComposioToolBySlugSpy.mockResolvedValueOnce(
1251
- toolMocks.transformedTool as unknown as Tool
1252
- );
1253
-
1254
- mockClient.toolRouter.session.executeMeta.mockResolvedValueOnce({
1244
+ mockClient.toolRouter.session.execute.mockResolvedValueOnce({
1245
data: { results: true },
1246
error: null,
1247
log_id: '123',
@@ -1260,8 +1250,8 @@ describe('Tools', () => {
1250
// Call the captured execute function
1251
const result = await capturedExecuteFn!('COMPOSIO_TOOL', { query: 'test' });
1252
1263
- expect(mockClient.toolRouter.session.executeMeta).toHaveBeenCalledWith(sessionId, {
1264
- slug: 'COMPOSIO_TOOL',
1253
+ expect(mockClient.toolRouter.session.execute).toHaveBeenCalledWith(sessionId, {
1254
+ tool_slug: 'COMPOSIO_TOOL',
1255
arguments: { query: 'test' },
1256
});
1257
expect(result).toEqual({
@@ -1290,13 +1280,7 @@ describe('Tools', () => {
1280
1281
context.tools.wrapToolsForToolRouter(sessionId, tools, modifiers);
1282
1293
- // Setup mocks for execution
1294
- const getRawComposioToolBySlugSpy = vi.spyOn(context.tools, 'getRawComposioToolBySlug');
1295
- getRawComposioToolBySlugSpy.mockResolvedValueOnce(
1296
- toolMocks.transformedTool as unknown as Tool
1297
- );
1298
-
1299
- mockClient.toolRouter.session.executeMeta.mockResolvedValueOnce({
1283
+ mockClient.toolRouter.session.execute.mockResolvedValueOnce({
1284
data: { results: true },
1285
error: null,
1286
log_id: '123',
@@ -1306,8 +1290,8 @@ describe('Tools', () => {
1290
await capturedExecuteFn!('COMPOSIO_TOOL', { query: 'test' });
1291
1292
expect(modifiers.beforeExecute).toHaveBeenCalled();
1309
- expect(mockClient.toolRouter.session.executeMeta).toHaveBeenCalledWith(sessionId, {
1310
- slug: 'COMPOSIO_TOOL',
1293
+ expect(mockClient.toolRouter.session.execute).toHaveBeenCalledWith(sessionId, {
1294
+ tool_slug: 'COMPOSIO_TOOL',
1295
arguments: { query: 'test', modified: true },
1296
});
1297
});
ts/packages/core/test/utils/mocks/client.mock.ts
+1
-1
@@ -18,7 +18,7 @@ export const mockClient = {
18
},
19
toolRouter: {
20
session: {
21
- executeMeta: vi.fn(),
21
+ execute: vi.fn(),
22
},
23
},
24
};