Skip to content

Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

fix(core): reuse fetched schemas for provider execution (#4103)

Alberto Schiabelc625edc0f7d6
diff --git a/.changeset/reuse-provider-tool-schemas.md b/.changeset/reuse-provider-tool-schemas.md
new file mode 100644
index 000000000..8e17bca90
--- /dev/null
+++ b/.changeset/reuse-provider-tool-schemas.md
@@ -0,0 +1,5 @@
+---
+'@composio/core': patch
+---
+
+Reuse fetched tool schemas when provider-wrapped tools execute to avoid a redundant retrieval request.
diff --git a/mise.lock b/mise.lock
index c4cd34b8e..6cd2fd42e 100644
--- a/mise.lock
+++ b/mise.lock
@@ -89,23 +89,23 @@ version = "3.12.13"
backend = "core:python"
[tools.python."platforms.linux-arm64"]
-checksum = "sha256:f3510827b61e7a2aa89a1bb7bac73d45521939c489cf43f4699618efaead0611"
-url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260805/cpython-3.12.13+20260805-aarch64-unknown-linux-gnu-install_only_stripped.tar.gz"
+checksum = "sha256:11e713ae1f969385907a76533cc554f6b2e3f1a84896009f91c3fc871034a170"
+url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260807/cpython-3.12.13+20260807-aarch64-unknown-linux-gnu-install_only_stripped.tar.gz"
provenance = "github-attestations"
[tools.python."platforms.linux-x64"]
-checksum = "sha256:f04a55ae95e8bd352cdff8da11c344fe609ec84795d106fa91b6620366d786fe"
-url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260805/cpython-3.12.13+20260805-x86_64-unknown-linux-gnu-install_only_stripped.tar.gz"
+checksum = "sha256:506191be3ee7bd190a8834dcdc1b3bc70aab50608deccc711935aa007239cabd"
+url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260807/cpython-3.12.13+20260807-x86_64-unknown-linux-gnu-install_only_stripped.tar.gz"
provenance = "github-attestations"
[tools.python."platforms.macos-arm64"]
-checksum = "sha256:a4b36035915038104aabee94d6f02827161da444296881fe4493cb98f70304b2"
-url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260805/cpython-3.12.13+20260805-aarch64-apple-darwin-install_only_stripped.tar.gz"
+checksum = "sha256:25baa97c65b3f0aa90e21131b4f9e80aef8899e8144006db8a9d2c1ab9e807e3"
+url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260807/cpython-3.12.13+20260807-aarch64-apple-darwin-install_only_stripped.tar.gz"
provenance = "github-attestations"
[tools.python."platforms.macos-x64"]
-checksum = "sha256:0d232711501680a619ea6113046603567d93be3218e326e4357557e771d1aec7"
-url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260805/cpython-3.12.13+20260805-x86_64-apple-darwin-install_only_stripped.tar.gz"
+checksum = "sha256:127053f1736f721e391ddb46f07585d05756e15bb8d757d3bbc0519738998ba1"
+url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260807/cpython-3.12.13+20260807-x86_64-apple-darwin-install_only_stripped.tar.gz"
provenance = "github-attestations"
[[tools.uv]]
diff --git a/ts/packages/core/src/models/Tools.ts b/ts/packages/core/src/models/Tools.ts
index 9311da674..8bc2dc48b 100644
--- a/ts/packages/core/src/models/Tools.ts
+++ b/ts/packages/core/src/models/Tools.ts
@@ -470,14 +470,12 @@ export class Tools<
'important' in queryParams.data ? queryParams.data.important : shouldAutoApplyImportant;
// check if the query params contains atleast one of the following: tools, toolkits, search, authConfigIds
- if (
- !(
- 'tools' in queryParams.data ||
- 'toolkits' in queryParams.data ||
- 'search' in queryParams.data ||
- 'authConfigIds' in queryParams.data
- )
- ) {
+ if (!(
+ 'tools' in queryParams.data ||
+ 'toolkits' in queryParams.data ||
+ 'search' in queryParams.data ||
+ 'authConfigIds' in queryParams.data
+ )) {
throw new ValidationError(
'Invalid tool list parameters, atleast one of the following parameters is required: tools, toolkits, search, authConfigIds'
);
@@ -766,33 +764,44 @@ export class Tools<
const { signal: _, ...modifiers } = options ?? {};
if (typeof arg2 === 'string') {
- const tool = await this.getRawComposioToolBySlug(
- arg2,
- {
- modifySchema: options?.modifySchema as TransformToolSchemaModifier,
- },
- requestOptions
- );
- return this.wrapToolsForProvider(
- userId,
- [tool],
- modifiers as ExecuteToolModifiers
- ) as TToolCollection;
+ const rawTool = await this.getRawComposioToolBySlug(arg2, undefined, requestOptions);
+ const [tool] = await this.applySchemaModifiers([rawTool], options?.modifySchema);
+ return this.wrapToolsForProvider(userId, [tool], modifiers as ExecuteToolModifiers, [
+ rawTool,
+ ]) as TToolCollection;
} else {
- const tools = await this.getRawComposioTools(
- arg2,
- {
- modifySchema: options?.modifySchema as TransformToolSchemaModifier,
- },
- requestOptions
- );
+ const rawTools = await this.getRawComposioTools(arg2, undefined, requestOptions);
+ const tools = await this.applySchemaModifiers(rawTools, options?.modifySchema);
return this.wrapToolsForProvider(
userId,
tools,
- modifiers as ExecuteToolModifiers
+ modifiers as ExecuteToolModifiers,
+ rawTools
) as TToolCollection;
}
}
+
+ private async applySchemaModifiers(
+ tools: Tool[],
+ modifier?: TransformToolSchemaModifier
+ ): Promise<Tool[]> {
+ if (modifier && typeof modifier !== 'function') {
+ throw new ComposioInvalidModifierError('Invalid schema modifier. Not a function.');
+ }
+ return Promise.all(
+ tools.map(tool => {
+ const schema = ToolSchema.parse(tool);
+ return modifier
+ ? modifier({
+ toolSlug: tool.slug,
+ toolkitSlug: tool.toolkit?.slug ?? 'unknown',
+ schema,
+ })
+ : schema;
+ })
+ );
+ }
+
/**
* @internal
* Creates a global execute tool function.
@@ -817,14 +826,16 @@ export class Tools<
* @param userId - The user id to get the tools for
* @param tools - The tools to wrap
* @param modifiers - The modifiers to be applied to the tools
+ * @param rawTools - The fetched schemas used during execution
* @returns The wrapped tools
*/
wrapToolsForProvider<T extends TProvider>(
userId: string,
tools: Tool[],
- modifiers?: ExecuteToolModifiers
+ modifiers?: ExecuteToolModifiers,
+ rawTools: Tool[] = tools.map(tool => ToolSchema.parse(tool))
): ReturnType<T['wrapTools']> {
- const executeToolFn = this.createExecuteToolFn(userId, modifiers);
+ const executeToolFn = this.createExecuteToolFn(userId, modifiers, rawTools);
return this.provider.wrapTools(tools, executeToolFn) as ReturnType<T['wrapTools']>;
}
@@ -854,21 +865,27 @@ export class Tools<
*
* @param {string} userId - The user id
* @param {ExecuteToolModifiers} modifiers - The modifiers to be applied to the tool
+ * @param {Tool[]} tools - The fetched tools available to the provider
* @returns {ExecuteToolFn} The execute tool function
*/
- private createExecuteToolFn(userId: string, modifiers?: ExecuteToolModifiers): ExecuteToolFn {
+ private createExecuteToolFn(
+ userId: string,
+ modifiers: ExecuteToolModifiers | undefined,
+ tools: Tool[]
+ ): ExecuteToolFn {
+ const toolBySlug = new Map(tools.map(tool => [tool.slug.toUpperCase(), tool]));
const executeToolFn = async (toolSlug: string, input: Record<string, unknown>) => {
- return await this.execute(
- toolSlug,
- {
- userId,
- arguments: input,
- // dangerously skip version check for agentic tool execution via providers
- // this can be safe because most agentic flows users fetch latest version and then execute the tool
- dangerouslySkipVersionCheck: true,
- },
- modifiers
- );
+ const body: ToolExecuteParams = {
+ userId,
+ arguments: input,
+ // dangerously skip version check for agentic tool execution via providers
+ // this can be safe because most agentic flows users fetch latest version and then execute the tool
+ dangerouslySkipVersionCheck: true,
+ };
+ const tool = toolBySlug.get(toolSlug.toUpperCase());
+ return tool
+ ? this.executeWithTool(toolSlug, this.parseToolExecuteParams(body), modifiers, tool)
+ : this.execute(toolSlug, body, modifiers);
};
return executeToolFn;
}
@@ -961,6 +978,52 @@ export class Tools<
}
}
+ private async executeWithTool(
+ slug: string,
+ body: ToolExecuteParams,
+ options: (ExecuteToolModifiers & ComposioRequestOptions) | undefined,
+ tool: Tool
+ ): Promise<ToolExecuteResponse> {
+ const requestOptions: ComposioRequestOptions | undefined =
+ options?.signal != null ? { signal: options.signal } : undefined;
+ const { signal: _, ...modifiers } = options ?? {};
+ const toolkitSlug = tool.toolkit?.slug ?? 'unknown';
+
+ const params = await this.applyBeforeExecuteModifiers(
+ tool,
+ {
+ toolSlug: slug,
+ toolkitSlug,
+ params: body,
+ },
+ modifiers as ExecuteToolModifiers,
+ requestOptions
+ );
+
+ let result = await this.executeComposioTool(tool, params, requestOptions);
+
+ result = await this.applyAfterExecuteModifiers(
+ tool,
+ {
+ toolSlug: slug,
+ toolkitSlug,
+ result,
+ },
+ (modifiers as ExecuteToolModifiers).afterExecute,
+ requestOptions
+ );
+
+ return result;
+ }
+
+ private parseToolExecuteParams(body: ToolExecuteParams): ToolExecuteParams {
+ const executeParams = ToolExecuteParamsSchema.safeParse(body);
+ if (!executeParams.success) {
+ throw new ValidationError('Invalid tool execute parameters', { cause: executeParams.error });
+ }
+ return executeParams.data;
+ }
+
/**
* Executes a given tool with the provided parameters.
*
@@ -1046,51 +1109,19 @@ export class Tools<
body: ToolExecuteParams,
options?: ExecuteToolModifiers & ComposioRequestOptions
): Promise<ToolExecuteResponse> {
- const executeParams = ToolExecuteParamsSchema.safeParse(body);
- if (!executeParams.success) {
- throw new ValidationError('Invalid tool execute parameters', { cause: executeParams.error });
- }
+ const executeParams = this.parseToolExecuteParams(body);
const requestOptions: ComposioRequestOptions | undefined =
options?.signal != null ? { signal: options.signal } : undefined;
- const { signal: _, ...modifiers } = options ?? {};
const tool = await this.getRawComposioToolBySlug(
slug,
{
- version: body.version,
- },
- requestOptions
- );
- const toolkitSlug = tool.toolkit?.slug ?? 'unknown';
-
- // Apply before execute modifiers
- const params = await this.applyBeforeExecuteModifiers(
- tool,
- {
- toolSlug: slug,
- toolkitSlug,
- params: executeParams.data,
+ version: executeParams.version,
},
- modifiers as ExecuteToolModifiers,
requestOptions
);
-
- let result = await this.executeComposioTool(tool, params, requestOptions);
-
- // Apply after execute modifiers
- result = await this.applyAfterExecuteModifiers(
- tool,
- {
- toolSlug: slug,
- toolkitSlug,
- result,
- },
- (modifiers as ExecuteToolModifiers).afterExecute,
- requestOptions
- );
-
- return result;
+ return this.executeWithTool(slug, executeParams, options, tool);
}
/**
diff --git a/ts/packages/core/test/tools/modifiers.test.ts b/ts/packages/core/test/tools/modifiers.test.ts
index 334d4fba3..6c98d4569 100644
--- a/ts/packages/core/test/tools/modifiers.test.ts
+++ b/ts/packages/core/test/tools/modifiers.test.ts
@@ -241,22 +241,14 @@ describe('Tools Modifiers', () => {
});
// Verify schema modification
- expect(getRawComposioToolBySlugSpy).toHaveBeenCalledWith(
- slug,
- {
- modifySchema: schemaModifier,
- },
- undefined
- );
- expect(mockTool.description).toBe('Enhanced GITHUB_GET_REPOS for better context');
- expect(mockTool.tags).toContain('enhanced');
- expect(mockTool.tags).toContain('modified');
- expect(mockTool.inputParameters).toHaveProperty(['properties', 'tracking']);
+ expect(getRawComposioToolBySlugSpy).toHaveBeenCalledWith(slug, undefined, undefined);
+ expect(schemaModifier).toHaveBeenCalledOnce();
// Verify execution function creation
expect(createExecuteToolFnSpy).toHaveBeenCalledWith(
userId,
- expect.objectContaining(executionModifiers)
+ expect.objectContaining(executionModifiers),
+ expect.any(Array)
);
// Mock a tool execution to verify the full flow
diff --git a/ts/packages/core/test/tools/tools.test.ts b/ts/packages/core/test/tools/tools.test.ts
index c19ca5ed2..6df710d27 100644
--- a/ts/packages/core/test/tools/tools.test.ts
+++ b/ts/packages/core/test/tools/tools.test.ts
@@ -739,13 +739,7 @@ describe('Tools', () => {
const result = await context.tools.get(userId, slug);
- expect(getRawComposioToolBySlugSpy).toHaveBeenCalledWith(
- slug,
- {
- modifySchema: undefined,
- },
- undefined
- );
+ expect(getRawComposioToolBySlugSpy).toHaveBeenCalledWith(slug, undefined, undefined);
expect(context.mockProvider.wrapTools).toHaveBeenCalledWith(
[toolMocks.transformedTool],
expect.any(Function)
@@ -764,16 +758,12 @@ describe('Tools', () => {
const result = await context.tools.get(userId, filters);
- expect(getRawComposioToolsSpy).toHaveBeenCalledWith(
- filters,
- { modifySchema: undefined },
- undefined
- );
+ expect(getRawComposioToolsSpy).toHaveBeenCalledWith(filters, undefined, undefined);
expect(context.mockProvider.wrapTools).toHaveBeenCalled();
expect(result).toEqual('wrapped-tools-collection');
});
- it('should pass modifiers to the underlying methods', async () => {
+ it('should apply schema modifiers before wrapping tools for the provider', async () => {
const userId = 'test-user';
const slug = 'TOOL_SLUG';
const schemaModifier = createSchemaModifier({
@@ -787,14 +777,22 @@ describe('Tools', () => {
await context.tools.get(userId, slug, { modifySchema: schemaModifier });
- expect(getRawComposioToolBySlugSpy).toHaveBeenCalledWith(
- slug,
- {
- modifySchema: schemaModifier,
- },
- undefined
+ expect(getRawComposioToolBySlugSpy).toHaveBeenCalledWith(slug, undefined, undefined);
+ expect(schemaModifier).toHaveBeenCalledOnce();
+ expect(context.mockProvider.wrapTools).toHaveBeenCalledWith(
+ [expect.objectContaining({ description: 'Modified description' })],
+ expect.any(Function)
);
});
+
+ it('should reject an invalid schema modifier when no tools are returned', async () => {
+ const invalidModifier = 'not a function' as unknown;
+ vi.spyOn(context.tools, 'getRawComposioTools').mockResolvedValueOnce([]);
+
+ await expect(
+ context.tools.get('test-user', { toolkits: ['github'] }, { modifySchema: invalidModifier })
+ ).rejects.toThrow('Invalid schema modifier. Not a function.');
+ });
});
describe('execute', () => {
@@ -2374,38 +2372,33 @@ describe('Tools', () => {
}
});
- it('should allow agentic provider execution with dangerouslySkipVersionCheck in createExecuteToolFn', async () => {
+ it('should reuse the fetched schema during agentic provider execution', async () => {
const context = createTestContext();
const userId = 'test-user';
-
- // Mock tool retrieval for the get method
+ const toolSlug = 'GITHUB_CREATE_ISSUE';
+ const fetchedTool = {
+ ...toolMocks.transformedTool,
+ slug: toolSlug,
+ toolkit: { slug: 'github', name: 'GitHub' },
+ } as unknown as Tool;
const getRawComposioToolBySlugSpy = vi.spyOn(context.tools, 'getRawComposioToolBySlug');
- getRawComposioToolBySlugSpy.mockResolvedValueOnce(
- toolMocks.transformedTool as unknown as Tool
- );
+ getRawComposioToolBySlugSpy.mockResolvedValue(fetchedTool);
- // Mock provider wrapping
let storedExecuteToolFn: ExecuteToolFn | undefined;
context.mockProvider.wrapTools.mockImplementation((_tools, executeToolFn) => {
storedExecuteToolFn = executeToolFn;
return 'wrapped-tools-collection';
});
- // Get the tool (this will internally create the execute tool function)
- await context.tools.get(userId, 'GITHUB_CREATE_ISSUE');
-
- expect(storedExecuteToolFn).toBeDefined();
-
- // Setup mocks for the actual execution
- const spies = await mockToolExecution(context.tools);
-
- // Call the execute function that was passed to the provider
- // This should succeed because createExecuteToolFn sets dangerouslySkipVersionCheck: true
- const result = await storedExecuteToolFn!('GITHUB_CREATE_ISSUE', { title: 'Test Issue' });
+ await context.tools.get(userId, toolSlug);
+ mockClient.tools.execute.mockResolvedValueOnce(toolMocks.rawToolExecuteResponse);
+ const result = await storedExecuteToolFn!(toolSlug, { title: 'Test Issue' });
expect(result).toEqual(toolMocks.toolExecuteResponse);
+ expect(getRawComposioToolBySlugSpy).toHaveBeenCalledTimes(1);
+ expect(mockClient.tools.retrieve).not.toHaveBeenCalled();
expect(mockClient.tools.execute).toHaveBeenCalledWith(
- 'COMPOSIO_TOOL',
+ toolSlug,
{
allow_tracing: undefined,
connected_account_id: undefined,
@@ -2419,6 +2412,113 @@ describe('Tools', () => {
undefined
);
});
+
+ it('should reject invalid agentic provider input before execution', async () => {
+ const context = createTestContext();
+ const toolSlug = 'GITHUB_CREATE_ISSUE';
+ const fetchedTool = {
+ ...toolMocks.transformedTool,
+ slug: toolSlug,
+ toolkit: { slug: 'github', name: 'GitHub' },
+ } as unknown as Tool;
+ const getRawComposioToolBySlugSpy = vi.spyOn(context.tools, 'getRawComposioToolBySlug');
+ getRawComposioToolBySlugSpy.mockResolvedValue(fetchedTool);
+ let storedExecuteToolFn: ExecuteToolFn | undefined;
+
+ context.mockProvider.wrapTools.mockImplementation((_tools, executeToolFn) => {
+ storedExecuteToolFn = executeToolFn;
+ return 'wrapped-tools-collection';
+ });
+
+ await context.tools.get('test-user', toolSlug);
+
+ await expect(
+ storedExecuteToolFn!(toolSlug, 42 as unknown as Record<string, unknown>)
+ ).rejects.toThrow(ValidationError);
+ expect(getRawComposioToolBySlugSpy).toHaveBeenCalledTimes(1);
+ expect(mockClient.tools.execute).not.toHaveBeenCalled();
+ });
+
+ it('should retrieve an unknown provider tool before execution', async () => {
+ const context = createTestContext();
+ const userId = 'test-user';
+ const fetchedToolSlug = 'GITHUB_CREATE_ISSUE';
+ const unknownToolSlug = 'GITHUB_GET_ISSUE';
+ const fetchedTool = {
+ ...toolMocks.transformedTool,
+ slug: fetchedToolSlug,
+ toolkit: { slug: 'github', name: 'GitHub' },
+ } as unknown as Tool;
+ const unknownTool = { ...fetchedTool, slug: unknownToolSlug };
+ const getRawComposioToolBySlugSpy = vi.spyOn(context.tools, 'getRawComposioToolBySlug');
+ getRawComposioToolBySlugSpy
+ .mockResolvedValueOnce(fetchedTool)
+ .mockResolvedValueOnce(unknownTool);
+ let storedExecuteToolFn: ExecuteToolFn | undefined;
+
+ context.mockProvider.wrapTools.mockImplementation((_tools, executeToolFn) => {
+ storedExecuteToolFn = executeToolFn;
+ return 'wrapped-tools-collection';
+ });
+
+ await context.tools.get(userId, fetchedToolSlug);
+ mockClient.tools.execute.mockResolvedValueOnce(toolMocks.rawToolExecuteResponse);
+ await storedExecuteToolFn!(unknownToolSlug, {});
+
+ expect(getRawComposioToolBySlugSpy).toHaveBeenCalledTimes(2);
+ expect(getRawComposioToolBySlugSpy).toHaveBeenNthCalledWith(
+ 2,
+ unknownToolSlug,
+ { version: undefined },
+ undefined
+ );
+ expect(mockClient.tools.execute).toHaveBeenCalledWith(
+ unknownToolSlug,
+ expect.objectContaining({ user_id: userId, version: 'latest' }),
+ undefined
+ );
+ });
+
+ it('should preserve execution metadata when modifySchema mutates the fetched tool', async () => {
+ const mockProvider = new MockProvider();
+ const tools = new Tools(mockClient, {
+ provider: mockProvider,
+ toolkitVersions: { 'test-toolkit': '20250101_00' },
+ });
+ const userId = 'test-user';
+ const toolSlug = 'GITHUB_CREATE_ISSUE';
+ const rawTool = {
+ ...toolMocks.rawTool,
+ slug: toolSlug,
+ toolkit: { slug: 'test-toolkit', name: 'Test Toolkit' },
+ };
+ let wrappedTools: Tool[] | undefined;
+ let storedExecuteToolFn: ExecuteToolFn | undefined;
+
+ mockClient.tools.retrieve.mockReset().mockResolvedValueOnce(rawTool);
+ mockProvider.wrapTools.mockImplementation((toolsToWrap, executeToolFn) => {
+ wrappedTools = toolsToWrap;
+ storedExecuteToolFn = executeToolFn;
+ return 'wrapped-tools';
+ });
+
+ await tools.get(userId, toolSlug, {
+ modifySchema: ({ schema }) => {
+ schema.toolkit = { slug: 'renamed-toolkit', name: 'Renamed Toolkit' };
+ return schema;
+ },
+ });
+ mockClient.tools.execute.mockResolvedValueOnce(toolMocks.rawToolExecuteResponse);
+ await storedExecuteToolFn!(toolSlug, {});
+
+ expect(wrappedTools?.[0].toolkit?.slug).toBe('renamed-toolkit');
+ expect(mockClient.tools.retrieve).toHaveBeenCalledTimes(1);
+ expect(mockClient.tools.execute).toHaveBeenCalledWith(
+ toolSlug,
+ expect.objectContaining({ version: '20250101_00' }),
+ undefined
+ );
+ });
});
});
});