@devries-cameron20 / composio Mirror · read-only / commits / 88118e20f
Fork 0

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 };