fix: pass full server response in explore API client tool

The client tool was cherry-picking fields and dropping documentation, inputSchema, and outputSchema from the server response. Now spreads the full result, consistent with the Vercel AI SDK tool.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: maslo55555

__tests__/unit/explore-api.test.ts

@@ -82,6 +82,33 @@ describe('Explore API Tool', () => {
 			expect(parsed[0].group).toBe('github');
 		});
 
+		test('should include documentation from the server response', async () => {
+			mockClient.exploreAPI.mockResolvedValue({
+				type: 'directory',
+				path: '/custom/myapi',
+				items: [
+					{ name: 'listItems', type: 'function' },
+					{ name: 'createItem', type: 'function' },
+				],
+				documentation: {
+					description: 'API for managing items',
+					examples: ['listItems()', 'createItem({ name: "test" })'],
+					tips: ['Use listItems before creating duplicates'],
+				},
+			});
+
+			const tool = createExploreApiTool(mockClient as any);
+			const result = await tool.func({ paths: '/custom/myapi' });
+			const parsed = JSON.parse(result);
+
+			expect(parsed).toHaveLength(1);
+			expect(parsed[0].success).toBe(true);
+			expect(parsed[0].documentation).toBeDefined();
+			expect(parsed[0].documentation.description).toBe('API for managing items');
+			expect(parsed[0].documentation.examples).toHaveLength(2);
+			expect(parsed[0].documentation.tips).toEqual(['Use listItems before creating duplicates']);
+		});
+
 		test('should handle errors gracefully', async () => {
 			mockClient.exploreAPI.mockRejectedValue(new Error('Path not found'));
 

packages/client/src/tools/explore-api.ts

@@ -13,18 +13,6 @@ export const exploreApiInputSchema = z.object({
 
 type ExploreApiInput = z.infer<typeof exploreApiInputSchema>;
 
-interface ExploreResult {
-	success: boolean;
-	path: string;
-	type?: 'directory' | 'function';
-	items?: Array<{ name: string; type: string }>;
-	name?: string;
-	description?: string;
-	definition?: unknown;
-	group?: string;
-	error?: string;
-}
-
 function normalizePaths(paths: string | string[]): string[] {
 	return Array.isArray(paths) ? paths : [paths];
 }
@@ -39,36 +27,14 @@ export function createExploreApiTool(client: AgentToolProtocolClient): Tool<Expl
 		func: async (input: ExploreApiInput) => {
 			const pathsToExplore = normalizePaths(input.paths);
 
-			const results: ExploreResult[] = await Promise.all(
+			const results = await Promise.all(
 				pathsToExplore.map(async (path) => {
 					try {
 						const result = await client.exploreAPI(path);
-
-						if (result.type === 'directory') {
-							return {
-								success: true,
-								type: 'directory' as const,
-								path: result.path,
-								items: result.items,
-							};
-						} else {
-							return {
-								success: true,
-								type: 'function' as const,
-								name: result.name,
-								description: result.description,
-								definition: result.definition,
-								group: result.group,
-								path: result.path,
-							};
-						}
+						return { success: true, ...result };
 					} catch (error: unknown) {
 						const message = error instanceof Error ? error.message : String(error);
-						return {
-							success: false,
-							path,
-							error: message,
-						};
+						return { success: false, path, error: message };
 					}
 				})
 			);