Fix workflow tool not executing when requireApproval is true and tool-call is approved (#11538)

## Description

<!-- Provide a brief description of the changes in this PR -->

## Related Issue(s)

<!-- Link to the issue(s) this PR addresses, using hashtag notation:
#123 -->
Fixes #11531
## Type of Change

- [x] Bug fix (non-breaking change that fixes an issue)
- [ ] New feature (non-breaking change that adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update
- [ ] Code refactoring
- [ ] Performance improvement
- [x] Test update

## Checklist

- [ ] I have made corresponding changes to the documentation (if
applicable)
- [ ] I have added tests that prove my fix is effective or that my
feature works


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

* **Bug Fixes**
* Fixed workflow tools failing to execute when requireApproval is
enabled and the tool call is approved.

<sub>✏️ Tip: You can customize this high-level summary in your review
settings.</sub>

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: taofeeq-deru

.changeset/big-fans-care.md

@@ -0,0 +1,5 @@
+---
+'@mastra/core': patch
+---
+
+Fix workflow tool not executing when requireApproval is true and tool call is approved

packages/core/src/agent/__tests__/tool-approval.test.ts

@@ -205,6 +205,78 @@ export function toolApprovalAndSuspensionTests(version: 'v1' | 'v2') {
         expect(name).toBe('Dero Israel');
       }, 500000);
 
+      it('should call findUserWorkflow with requireToolApproval on workflow', async () => {
+        const findUserStep = createStep({
+          id: 'find-user-step',
+          description: 'This is a test step that returns the name and email',
+          inputSchema: z.object({
+            name: z.string(),
+          }),
+          outputSchema: z.object({
+            name: z.string(),
+            email: z.string(),
+          }),
+          execute: async ({ inputData }) => {
+            return mockFindUser(inputData) as Promise<Record<string, any>>;
+          },
+        });
+
+        const findUserWorkflow = createWorkflow({
+          id: 'find-user-workflow',
+          description: 'This is a test tool that returns the name and email',
+          inputSchema: z.object({
+            name: z.string(),
+          }),
+          outputSchema: z.object({
+            name: z.string(),
+            email: z.string(),
+          }),
+        })
+          .then(findUserStep)
+          .commit();
+
+        const userAgent = new Agent({
+          id: 'user-agent',
+          name: 'User Agent',
+          instructions: 'You are an agent that can get list of users using findUserWorkflow.',
+          model: openaiModel,
+          workflows: { findUserWorkflow },
+          defaultOptions: {
+            requireToolApproval: true,
+          },
+        });
+
+        const mastra = new Mastra({
+          agents: { userAgent },
+          logger: false,
+          storage: mockStorage,
+        });
+
+        const agentOne = mastra.getAgent('userAgent');
+
+        let toolCall;
+        const stream = await agentOne.stream('Find the user with name - Dero Israel');
+        let toolCallId = '';
+        for await (const _chunk of stream.fullStream) {
+          if (_chunk.type === 'tool-call-approval') {
+            toolCallId = _chunk.payload.toolCallId;
+          }
+        }
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        const resumeStream = await agentOne.approveToolCall({ runId: stream.runId, toolCallId });
+        for await (const _chunk of resumeStream.fullStream) {
+        }
+
+        const toolResults = await resumeStream.toolResults;
+
+        toolCall = toolResults?.find((result: any) => result.payload.toolName === 'workflow-findUserWorkflow')?.payload;
+
+        const name = toolCall?.result?.result?.name;
+
+        expect(mockFindUser).toHaveBeenCalled();
+        expect(name).toBe('Dero Israel');
+      }, 500000);
+
       it('should call findUserTool with requireToolApproval on tool and resume via stream when autoResumeSuspendedTools is true', async () => {
         const findUserTool = createTool({
           id: 'Find user tool',

packages/core/src/loop/workflows/agentic-execution/tool-call-step.ts

@@ -343,6 +343,12 @@ export function createToolCallStep<
           await removeToolMetadata(inputData.toolName, 'suspension');
         }
 
+        //this is to avoid passing resume data to the tool if it's not needed
+        const resumeDataToPassToToolOptions =
+          toolRequiresApproval && Object.keys(resumeData).length === 1 && 'approved' in resumeData
+            ? undefined
+            : resumeData;
+
         const toolOptions: MastraToolInvocationOptions = {
           abortSignal: options?.abortSignal,
           toolCallId: inputData.toolCallId,
@@ -389,7 +395,7 @@ export function createToolCallStep<
               },
             );
           },
-          resumeData,
+          resumeData: resumeDataToPassToToolOptions,
         };
 
         const result = await tool.execute(args, toolOptions);