fix(core): propagate agent logger to combined processor workflow (#16369)

### description

- Fixes logger propagation for processor-combined internal workflows so
processor step failures use the configured agent logger instead of
default console logging.
Adds a focused regression test to prevent this from regressing.

Related Issue(s)

fixes #16364

### Type of Change
[x] Bug fix (non-breaking change that fixes an issue)
[x] Test update

#### Checklist
[x] 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
-->

## ELI5

When you combine multiple processors into a workflow within an agent,
the internal workflow wasn't using the agent's logger. So if something
went wrong, errors were printed to the console instead of going through
your configured logging system (like DataDog). This PR adds one line of
code to make sure the internal workflow uses the agent's logger, so all
error logs flow through the proper logging pipeline.

---

## Changes

### agent.ts
Added explicit logger propagation in
`Agent.combineProcessorsIntoWorkflow()`. After creating the chained
processor workflow via `createWorkflow(...)`, the code now calls
`workflow.__setLogger(this.logger)` to ensure the internal workflow uses
the agent's configured logger instance instead of the default console
logger.

### agent-processor.test.ts
Added a new regression test under "Workflow as Processor" that verifies
logger propagation works correctly. The test creates an input processor
that fails, runs it through `agent.generate()`, and confirms that:
- The error is properly rejected with "Input processor error"
- The agent's `logger.error` is called with a message containing the
processor id
- The agent's `logger.trackException` is invoked

### Changeset
Updated `.changeset/blue-snails-see.md` to document a `patch` release
for `@mastra/core` describing the logging fix for processor-combined
workflows.

---

## Impact

- Processor step failures in combined workflows now route through the
configured agent logger, enabling proper log aggregation and structured
logging pipelines
- Breaking change: None
- Tests added: Yes, with focused regression test to prevent future
regressions

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

Author: Neha Prasad

.changeset/blue-snails-see.md

@@ -0,0 +1,5 @@
+---
+'@mastra/core': patch
+---
+
+Fixed processor-combined workflows to use the agent logger so processor step failures are logged through the configured logger instead of console output.

packages/core/src/agent/agent-processor.test.ts

@@ -1,8 +1,9 @@
 import type { LanguageModelV2Prompt } from '@ai-sdk/provider-v5';
 import { MockLanguageModelV1 } from '@internal/ai-sdk-v4/test';
 import { convertArrayToReadableStream, MockLanguageModelV2 } from '@internal/ai-sdk-v5/test';
-import { beforeEach, describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { z } from 'zod/v4';
+import { noopLogger } from '../logger';
 import type { Processor, ProcessOutputStepArgs } from '../processors/index';
 import { isProcessorWorkflow } from '../processors/index';
 import { ProcessorStepInputSchema, ProcessorStepOutputSchema } from '../processors/step-schema';
@@ -2567,6 +2568,43 @@ describe('v1 model - output processors', () => {
 });
 
 describe('Workflow as Processor', () => {
+  it('should use the agent logger for internal combined processor workflows', async () => {
+    const failingProcessor: Processor = {
+      id: 'failing-processor',
+      processInput: async () => {
+        throw new Error('processor failed');
+      },
+    };
+
+    const agent = new Agent({
+      id: 'logger-propagation-test-agent',
+      name: 'Logger Propagation Test Agent',
+      instructions: 'You are a helpful assistant.',
+      model: new MockLanguageModelV2({
+        doGenerate: async () => ({
+          content: [{ type: 'text', text: 'should not get here' }],
+          finishReason: 'stop',
+          usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+          rawCall: { rawPrompt: null, rawSettings: {} },
+          warnings: [],
+        }),
+      }),
+      inputProcessors: [failingProcessor],
+    });
+
+    const logger = {
+      ...noopLogger,
+      debug: vi.fn(),
+      error: vi.fn(),
+      trackException: vi.fn(),
+    };
+    agent.__setLogger(logger);
+
+    await expect(agent.generate('trigger failure')).rejects.toThrow('Input processor error');
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('processor:failing-processor'));
+    expect(logger.trackException).toHaveBeenCalled();
+  });
+
   describe('input processor workflow', () => {
     it('should execute a workflow as an input processor', async () => {
       let workflowExecuted = false;

packages/core/src/agent/agent.ts

@@ -848,6 +848,7 @@ export class Agent<
         },
       },
     });
+    workflow.__setLogger(this.logger);
 
     for (const [index, processorOrWorkflow] of validProcessors.entries()) {
       // Convert processor to step, or use workflow directly (nested workflows are allowed)