@office-ai/aioncli-core 0.8.1 → 0.18.4

package/dist/src/tools/mcp-tool.test.js

@@ -17,6 +17,14 @@ const mockCallableToolInstance = {
     callTool: mockCallTool,
     // Add other methods if DiscoveredMCPTool starts using them
 };
+const createSdkResponse = (toolName, response) => [
+    {
+        functionResponse: {
+            name: toolName,
+            response,
+        },
+    },
+];
 describe('generateValidName', () => {
     it('should return a valid name for a simple function', () => {
         expect(generateValidName('myFunction')).toBe('myFunction');
@@ -30,14 +38,12 @@ describe('generateValidName', () => {
     it('should handle names with only invalid characters', () => {
         expect(generateValidName('!@#$%^&*()')).toBe('__________');
     });
-    it('should handle names that are exactly 63 characters long', () => {
-        expect(generateValidName('a'.repeat(63)).length).toBe(63);
-    });
-    it('should handle names that are exactly 64 characters long', () => {
-        expect(generateValidName('a'.repeat(64)).length).toBe(63);
-    });
-    it('should handle names that are longer than 64 characters', () => {
-        expect(generateValidName('a'.repeat(80)).length).toBe(63);
+    it.each([
+        { length: 63, expected: 63, description: 'exactly 63 characters' },
+        { length: 64, expected: 63, description: 'exactly 64 characters' },
+        { length: 80, expected: 63, description: 'longer than 64 characters' },
+    ])('should handle names that are $description long', ({ length, expected }) => {
+        expect(generateValidName('a'.repeat(length)).length).toBe(expected);
     });
 });
 describe('DiscoveredMCPTool', () => {
@@ -189,20 +195,9 @@ describe('DiscoveredMCPTool', () => {
         it('should handle a simple text response correctly', async () => {
             const params = { param: 'test' };
             const successMessage = 'This is a success message.';
-            // Simulate the response from the GenAI SDK, which wraps the MCP
-            // response in a functionResponse Part.
-            const sdkResponse = [
-                {
-                    functionResponse: {
-                        name: serverToolName,
-                        response: {
-                            // The `content` array contains MCP ContentBlocks.
-                            content: [{ type: 'text', text: successMessage }],
-                        },
-                    },
-                },
-            ];
-            mockCallTool.mockResolvedValue(sdkResponse);
+            mockCallTool.mockResolvedValue(createSdkResponse(serverToolName, {
+                content: [{ type: 'text', text: successMessage }],
+            }));
             const invocation = tool.build(params);
             const toolResult = await invocation.execute(new AbortController().signal);
             // 1. Assert that the llmContent sent to the scheduler is a clean Part array.
@@ -216,23 +211,15 @@ describe('DiscoveredMCPTool', () => {
         });
         it('should handle an AudioBlock response', async () => {
             const params = { param: 'play' };
-            const sdkResponse = [
-                {
-                    functionResponse: {
-                        name: serverToolName,
-                        response: {
-                            content: [
-                                {
-                                    type: 'audio',
-                                    data: 'BASE64_AUDIO_DATA',
-                                    mimeType: 'audio/mp3',
-                                },
-                            ],
-                        },
+            mockCallTool.mockResolvedValue(createSdkResponse(serverToolName, {
+                content: [
+                    {
+                        type: 'audio',
+                        data: 'BASE64_AUDIO_DATA',
+                        mimeType: 'audio/mp3',
                     },
-                },
-            ];
-            mockCallTool.mockResolvedValue(sdkResponse);
+                ],
+            }));
             const invocation = tool.build(params);
             const toolResult = await invocation.execute(new AbortController().signal);
             expect(toolResult.llmContent).toEqual([
@@ -250,24 +237,16 @@ describe('DiscoveredMCPTool', () => {
         });
         it('should handle a ResourceLinkBlock response', async () => {
             const params = { param: 'get' };
-            const sdkResponse = [
-                {
-                    functionResponse: {
-                        name: serverToolName,
-                        response: {
-                            content: [
-                                {
-                                    type: 'resource_link',
-                                    uri: 'file:///path/to/thing',
-                                    name: 'resource-name',
-                                    title: 'My Resource',
-                                },
-                            ],
-                        },
+            mockCallTool.mockResolvedValue(createSdkResponse(serverToolName, {
+                content: [
+                    {
+                        type: 'resource_link',
+                        uri: 'file:///path/to/thing',
+                        name: 'resource-name',
+                        title: 'My Resource',
                     },
-                },
-            ];
-            mockCallTool.mockResolvedValue(sdkResponse);
+                ],
+            }));
             const invocation = tool.build(params);
             const toolResult = await invocation.execute(new AbortController().signal);
             expect(toolResult.llmContent).toEqual([
@@ -279,26 +258,18 @@ describe('DiscoveredMCPTool', () => {
         });
         it('should handle an embedded text ResourceBlock response', async () => {
             const params = { param: 'get' };
-            const sdkResponse = [
-                {
-                    functionResponse: {
-                        name: serverToolName,
-                        response: {
-                            content: [
-                                {
-                                    type: 'resource',
-                                    resource: {
-                                        uri: 'file:///path/to/text.txt',
-                                        text: 'This is the text content.',
-                                        mimeType: 'text/plain',
-                                    },
-                                },
-                            ],
+            mockCallTool.mockResolvedValue(createSdkResponse(serverToolName, {
+                content: [
+                    {
+                        type: 'resource',
+                        resource: {
+                            uri: 'file:///path/to/text.txt',
+                            text: 'This is the text content.',
+                            mimeType: 'text/plain',
                         },
                     },
-                },
-            ];
-            mockCallTool.mockResolvedValue(sdkResponse);
+                ],
+            }));
             const invocation = tool.build(params);
             const toolResult = await invocation.execute(new AbortController().signal);
             expect(toolResult.llmContent).toEqual([
@@ -308,26 +279,18 @@ describe('DiscoveredMCPTool', () => {
         });
         it('should handle an embedded binary ResourceBlock response', async () => {
             const params = { param: 'get' };
-            const sdkResponse = [
-                {
-                    functionResponse: {
-                        name: serverToolName,
-                        response: {
-                            content: [
-                                {
-                                    type: 'resource',
-                                    resource: {
-                                        uri: 'file:///path/to/data.bin',
-                                        blob: 'BASE64_BINARY_DATA',
-                                        mimeType: 'application/octet-stream',
-                                    },
-                                },
-                            ],
+            mockCallTool.mockResolvedValue(createSdkResponse(serverToolName, {
+                content: [
+                    {
+                        type: 'resource',
+                        resource: {
+                            uri: 'file:///path/to/data.bin',
+                            blob: 'BASE64_BINARY_DATA',
+                            mimeType: 'application/octet-stream',
                         },
                     },
-                },
-            ];
-            mockCallTool.mockResolvedValue(sdkResponse);
+                ],
+            }));
             const invocation = tool.build(params);
             const toolResult = await invocation.execute(new AbortController().signal);
             expect(toolResult.llmContent).toEqual([
@@ -345,25 +308,17 @@ describe('DiscoveredMCPTool', () => {
         });
         it('should handle a mix of content block types', async () => {
             const params = { param: 'complex' };
-            const sdkResponse = [
-                {
-                    functionResponse: {
-                        name: serverToolName,
-                        response: {
-                            content: [
-                                { type: 'text', text: 'First part.' },
-                                {
-                                    type: 'image',
-                                    data: 'BASE64_IMAGE_DATA',
-                                    mimeType: 'image/jpeg',
-                                },
-                                { type: 'text', text: 'Second part.' },
-                            ],
-                        },
+            mockCallTool.mockResolvedValue(createSdkResponse(serverToolName, {
+                content: [
+                    { type: 'text', text: 'First part.' },
+                    {
+                        type: 'image',
+                        data: 'BASE64_IMAGE_DATA',
+                        mimeType: 'image/jpeg',
                     },
-                },
-            ];
-            mockCallTool.mockResolvedValue(sdkResponse);
+                    { type: 'text', text: 'Second part.' },
+                ],
+            }));
             const invocation = tool.build(params);
             const toolResult = await invocation.execute(new AbortController().signal);
             expect(toolResult.llmContent).toEqual([
@@ -383,20 +338,12 @@ describe('DiscoveredMCPTool', () => {
         });
         it('should ignore unknown content block types', async () => {
             const params = { param: 'test' };
-            const sdkResponse = [
-                {
-                    functionResponse: {
-                        name: serverToolName,
-                        response: {
-                            content: [
-                                { type: 'text', text: 'Valid part.' },
-                                { type: 'future_block', data: 'some-data' },
-                            ],
-                        },
-                    },
-                },
-            ];
-            mockCallTool.mockResolvedValue(sdkResponse);
+            mockCallTool.mockResolvedValue(createSdkResponse(serverToolName, {
+                content: [
+                    { type: 'text', text: 'Valid part.' },
+                    { type: 'future_block', data: 'some-data' },
+                ],
+            }));
             const invocation = tool.build(params);
             const toolResult = await invocation.execute(new AbortController().signal);
             expect(toolResult.llmContent).toEqual([{ text: 'Valid part.' }]);
@@ -404,38 +351,30 @@ describe('DiscoveredMCPTool', () => {
         });
         it('should handle a complex mix of content block types', async () => {
             const params = { param: 'super-complex' };
-            const sdkResponse = [
-                {
-                    functionResponse: {
-                        name: serverToolName,
-                        response: {
-                            content: [
-                                { type: 'text', text: 'Here is a resource.' },
-                                {
-                                    type: 'resource_link',
-                                    uri: 'file:///path/to/resource',
-                                    name: 'resource-name',
-                                    title: 'My Resource',
-                                },
-                                {
-                                    type: 'resource',
-                                    resource: {
-                                        uri: 'file:///path/to/text.txt',
-                                        text: 'Embedded text content.',
-                                        mimeType: 'text/plain',
-                                    },
-                                },
-                                {
-                                    type: 'image',
-                                    data: 'BASE64_IMAGE_DATA',
-                                    mimeType: 'image/jpeg',
-                                },
-                            ],
+            mockCallTool.mockResolvedValue(createSdkResponse(serverToolName, {
+                content: [
+                    { type: 'text', text: 'Here is a resource.' },
+                    {
+                        type: 'resource_link',
+                        uri: 'file:///path/to/resource',
+                        name: 'resource-name',
+                        title: 'My Resource',
+                    },
+                    {
+                        type: 'resource',
+                        resource: {
+                            uri: 'file:///path/to/text.txt',
+                            text: 'Embedded text content.',
+                            mimeType: 'text/plain',
                         },
                     },
-                },
-            ];
-            mockCallTool.mockResolvedValue(sdkResponse);
+                    {
+                        type: 'image',
+                        data: 'BASE64_IMAGE_DATA',
+                        mimeType: 'image/jpeg',
+                    },
+                ],
+            }));
             const invocation = tool.build(params);
             const toolResult = await invocation.execute(new AbortController().signal);
             expect(toolResult.llmContent).toEqual([
@@ -457,6 +396,8 @@ describe('DiscoveredMCPTool', () => {
             expect(toolResult.returnDisplay).toBe('Here is a resource.\n[Link to My Resource: file:///path/to/resource]\nEmbedded text content.\n[Image: image/jpeg]');
         });
         describe('AbortSignal support', () => {
+            const MOCK_TOOL_DELAY = 1000;
+            const ABORT_DELAY = 50;
             it('should abort immediately if signal is already aborted', async () => {
                 const params = { param: 'test' };
                 const controller = new AbortController();
@@ -482,28 +423,20 @@ describe('DiscoveredMCPTool', () => {
                                 },
                             },
                         ]);
-                    }, 1000);
+                    }, MOCK_TOOL_DELAY);
                 }));
                 const invocation = tool.build(params);
                 const promise = invocation.execute(controller.signal);
                 // Abort after a short delay to simulate cancellation during execution
-                setTimeout(() => controller.abort(), 50);
+                setTimeout(() => controller.abort(), ABORT_DELAY);
                 await expect(promise).rejects.toThrow('Tool call aborted');
             });
             it('should complete successfully if not aborted', async () => {
                 const params = { param: 'test' };
                 const controller = new AbortController();
-                const successResponse = [
-                    {
-                        functionResponse: {
-                            name: serverToolName,
-                            response: {
-                                content: [{ type: 'text', text: 'Success' }],
-                            },
-                        },
-                    },
-                ];
-                mockCallTool.mockResolvedValue(successResponse);
+                mockCallTool.mockResolvedValue(createSdkResponse(serverToolName, {
+                    content: [{ type: 'text', text: 'Success' }],
+                }));
                 const invocation = tool.build(params);
                 const result = await invocation.execute(controller.signal);
                 expect(result.llmContent).toEqual([{ text: 'Success' }]);
@@ -515,15 +448,7 @@ describe('DiscoveredMCPTool', () => {
             it('should handle tool error even when abort signal is provided', async () => {
                 const params = { param: 'test' };
                 const controller = new AbortController();
-                const errorResponse = [
-                    {
-                        functionResponse: {
-                            name: serverToolName,
-                            response: { error: { isError: true } },
-                        },
-                    },
-                ];
-                mockCallTool.mockResolvedValue(errorResponse);
+                mockCallTool.mockResolvedValue(createSdkResponse(serverToolName, { error: { isError: true } }));
                 const invocation = tool.build(params);
                 const result = await invocation.execute(controller.signal);
                 expect(result.error?.type).toBe(ToolErrorType.MCP_TOOL_ERROR);
@@ -537,38 +462,40 @@ describe('DiscoveredMCPTool', () => {
                 const invocation = tool.build(params);
                 await expect(invocation.execute(controller.signal)).rejects.toThrow(expectedError);
             });
-            it('should cleanup event listeners properly on successful completion', async () => {
-                const params = { param: 'test' };
-                const controller = new AbortController();
-                const successResponse = [
-                    {
-                        functionResponse: {
-                            name: serverToolName,
-                            response: {
-                                content: [{ type: 'text', text: 'Success' }],
-                            },
-                        },
+            it.each([
+                {
+                    name: 'successful completion',
+                    setup: () => {
+                        mockCallTool.mockResolvedValue(createSdkResponse(serverToolName, {
+                            content: [{ type: 'text', text: 'Success' }],
+                        }));
                     },
-                ];
-                mockCallTool.mockResolvedValue(successResponse);
-                const invocation = tool.build(params);
-                await invocation.execute(controller.signal);
-                controller.abort();
-                expect(controller.signal.aborted).toBe(true);
-            });
-            it('should cleanup event listeners properly on error', async () => {
+                    expectError: false,
+                },
+                {
+                    name: 'error',
+                    setup: () => {
+                        mockCallTool.mockRejectedValue(new Error('Tool execution failed'));
+                    },
+                    expectError: true,
+                },
+            ])('should cleanup event listeners properly on $name', async ({ setup, expectError }) => {
                 const params = { param: 'test' };
                 const controller = new AbortController();
-                const expectedError = new Error('Tool execution failed');
-                mockCallTool.mockRejectedValue(expectedError);
+                setup();
                 const invocation = tool.build(params);
-                try {
-                    await invocation.execute(controller.signal);
+                if (expectError) {
+                    try {
+                        await invocation.execute(controller.signal);
+                    }
+                    catch (_error) {
+                        // Expected error
+                    }
                 }
-                catch (error) {
-                    expect(error).toBe(expectedError);
+                else {
+                    await invocation.execute(controller.signal);
                 }
-                // Verify cleanup by aborting after error
+                // Verify cleanup by aborting after execution
                 controller.abort();
                 expect(controller.signal.aborted).toBe(true);
             });
@@ -609,22 +536,32 @@ describe('DiscoveredMCPTool', () => {
                 throw new Error('Confirmation details not in expected format or was false');
             }
         });
-        it('should add server to allowlist on ProceedAlwaysServer', async () => {
-            const invocation = tool.build({ param: 'mock' });
-            const confirmation = await invocation.shouldConfirmExecute(new AbortController().signal);
-            expect(confirmation).not.toBe(false);
-            if (confirmation &&
-                typeof confirmation === 'object' &&
-                'onConfirm' in confirmation &&
-                typeof confirmation.onConfirm === 'function') {
-                await confirmation.onConfirm(ToolConfirmationOutcome.ProceedAlwaysServer);
-                expect(invocation.constructor.allowlist.has(serverName)).toBe(true);
-            }
-            else {
-                throw new Error('Confirmation details or onConfirm not in expected format');
-            }
-        });
-        it('should add tool to allowlist on ProceedAlwaysTool', async () => {
+        it.each([
+            {
+                outcome: ToolConfirmationOutcome.ProceedAlwaysServer,
+                description: 'add server to allowlist on ProceedAlwaysServer',
+                shouldAddServer: true,
+                shouldAddTool: false,
+            },
+            {
+                outcome: ToolConfirmationOutcome.ProceedAlwaysTool,
+                description: 'add tool to allowlist on ProceedAlwaysTool',
+                shouldAddServer: false,
+                shouldAddTool: true,
+            },
+            {
+                outcome: ToolConfirmationOutcome.Cancel,
+                description: 'handle Cancel confirmation outcome',
+                shouldAddServer: false,
+                shouldAddTool: false,
+            },
+            {
+                outcome: ToolConfirmationOutcome.ProceedOnce,
+                description: 'handle ProceedOnce confirmation outcome',
+                shouldAddServer: false,
+                shouldAddTool: false,
+            },
+        ])('should $description', async ({ outcome, shouldAddServer, shouldAddTool }) => {
             const toolAllowlistKey = `${serverName}.${serverToolName}`;
             const invocation = tool.build({ param: 'mock' });
             const confirmation = await invocation.shouldConfirmExecute(new AbortController().signal);
@@ -633,42 +570,9 @@ describe('DiscoveredMCPTool', () => {
                 typeof confirmation === 'object' &&
                 'onConfirm' in confirmation &&
                 typeof confirmation.onConfirm === 'function') {
-                await confirmation.onConfirm(ToolConfirmationOutcome.ProceedAlwaysTool);
-                expect(invocation.constructor.allowlist.has(toolAllowlistKey)).toBe(true);
-            }
-            else {
-                throw new Error('Confirmation details or onConfirm not in expected format');
-            }
-        });
-        it('should handle Cancel confirmation outcome', async () => {
-            const invocation = tool.build({ param: 'mock' });
-            const confirmation = await invocation.shouldConfirmExecute(new AbortController().signal);
-            expect(confirmation).not.toBe(false);
-            if (confirmation &&
-                typeof confirmation === 'object' &&
-                'onConfirm' in confirmation &&
-                typeof confirmation.onConfirm === 'function') {
-                // Cancel should not add anything to allowlist
-                await confirmation.onConfirm(ToolConfirmationOutcome.Cancel);
-                expect(invocation.constructor.allowlist.has(serverName)).toBe(false);
-                expect(invocation.constructor.allowlist.has(`${serverName}.${serverToolName}`)).toBe(false);
-            }
-            else {
-                throw new Error('Confirmation details or onConfirm not in expected format');
-            }
-        });
-        it('should handle ProceedOnce confirmation outcome', async () => {
-            const invocation = tool.build({ param: 'mock' });
-            const confirmation = await invocation.shouldConfirmExecute(new AbortController().signal);
-            expect(confirmation).not.toBe(false);
-            if (confirmation &&
-                typeof confirmation === 'object' &&
-                'onConfirm' in confirmation &&
-                typeof confirmation.onConfirm === 'function') {
-                // ProceedOnce should not add anything to allowlist
-                await confirmation.onConfirm(ToolConfirmationOutcome.ProceedOnce);
-                expect(invocation.constructor.allowlist.has(serverName)).toBe(false);
-                expect(invocation.constructor.allowlist.has(`${serverName}.${serverToolName}`)).toBe(false);
+                await confirmation.onConfirm(outcome);
+                expect(invocation.constructor.allowlist.has(serverName)).toBe(shouldAddServer);
+                expect(invocation.constructor.allowlist.has(toolAllowlistKey)).toBe(shouldAddTool);
             }
             else {
                 throw new Error('Confirmation details or onConfirm not in expected format');
@@ -679,27 +583,36 @@ describe('DiscoveredMCPTool', () => {
         const mockConfig = (isTrusted) => ({
             isTrustedFolder: () => isTrusted,
         });
-        it('should return false if trust is true and folder is trusted', async () => {
-            const trustedTool = new DiscoveredMCPTool(mockCallableToolInstance, serverName, serverToolName, baseDescription, inputSchema, true, // trust = true
-            undefined, mockConfig(true));
-            const invocation = trustedTool.build({ param: 'mock' });
-            expect(await invocation.shouldConfirmExecute(new AbortController().signal)).toBe(false);
-        });
-        it('should return confirmation details if trust is true but folder is not trusted', async () => {
-            const trustedTool = new DiscoveredMCPTool(mockCallableToolInstance, serverName, serverToolName, baseDescription, inputSchema, true, // trust = true
-            undefined, mockConfig(false));
-            const invocation = trustedTool.build({ param: 'mock' });
-            const confirmation = await invocation.shouldConfirmExecute(new AbortController().signal);
-            expect(confirmation).not.toBe(false);
-            expect(confirmation).toHaveProperty('type', 'mcp');
-        });
-        it('should return confirmation details if trust is false, even if folder is trusted', async () => {
-            const untrustedTool = new DiscoveredMCPTool(mockCallableToolInstance, serverName, serverToolName, baseDescription, inputSchema, false, // trust = false
-            undefined, mockConfig(true));
-            const invocation = untrustedTool.build({ param: 'mock' });
+        it.each([
+            {
+                trust: true,
+                isTrusted: true,
+                shouldConfirm: false,
+                description: 'return false if trust is true and folder is trusted',
+            },
+            {
+                trust: true,
+                isTrusted: false,
+                shouldConfirm: true,
+                description: 'return confirmation details if trust is true but folder is not trusted',
+            },
+            {
+                trust: false,
+                isTrusted: true,
+                shouldConfirm: true,
+                description: 'return confirmation details if trust is false, even if folder is trusted',
+            },
+        ])('should $description', async ({ trust, isTrusted, shouldConfirm }) => {
+            const testTool = new DiscoveredMCPTool(mockCallableToolInstance, serverName, serverToolName, baseDescription, inputSchema, trust, undefined, mockConfig(isTrusted));
+            const invocation = testTool.build({ param: 'mock' });
             const confirmation = await invocation.shouldConfirmExecute(new AbortController().signal);
-            expect(confirmation).not.toBe(false);
-            expect(confirmation).toHaveProperty('type', 'mcp');
+            if (shouldConfirm) {
+                expect(confirmation).not.toBe(false);
+                expect(confirmation).toHaveProperty('type', 'mcp');
+            }
+            else {
+                expect(confirmation).toBe(false);
+            }
         });
     });
     describe('DiscoveredMCPToolInvocation', () => {