fix: apply output processors to messages saved during network execution (#12346)

## Description

When using `agent.network()`, output processors configured on the agent
were not being applied to messages saved to storage. This broke
functionality like trace ID injection for feedback attribution (e.g.,
Braintrust integration).

**Root cause**: The network loop saves messages directly via
`memory.saveMessages()` at ~10 locations, bypassing the output processor
pipeline that normally runs during `agent.generate()`.

**Solution**:
- Created a `saveMessagesWithProcessors()` helper function that applies
output processors via `ProcessorRunner` before saving
- Created a `ProcessorRunner` instance in `createNetworkLoop()` using
the agent's configured output processors
- Replaced all `memory.saveMessages()` calls with the helper function

This ensures output processors are applied to all messages saved during
network execution including:
- Router direct responses
- Completion check results
- Agent/workflow execution results
- Tool execution results

## Related Issue(s)

Fixes #12300

## 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
- [ ] Test update

## Checklist

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

🤖 Generated with [Claude Code](https://claude.ai/claude-code)

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

* **Bug Fixes**
* Output processors are now correctly applied to messages saved during
network execution, ensuring configured processors (e.g., trace
injectors) run on all persisted messages.

* **Tests**
* Added test coverage verifying output processors are applied to saved
messages in network flows.

* **Chores**
* Added a changeset entry to publish the patch fixing processor
application.

<sub>✏️ Tip: You can customize this high-level summary in your review
settings.</sub>
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: NikAiyer

.changeset/pink-sloths-press.md

@@ -0,0 +1,5 @@
+---
+'@mastra/core': patch
+---
+
+Fixed output processors not being applied to messages saved during network execution. When using agent.network(), configured output processors (like TraceIdInjector for feedback attribution) are now correctly applied to all messages before they are saved to storage.

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

@@ -5468,3 +5468,156 @@ describe('Agent - network - message history transfer to sub-agents', () => {
     expect(secondCallPrompt).not.toContain('selectionReason');
   });
 });
+
+describe('Agent - network - output processors', () => {
+  it('should apply output processors to messages saved during network execution', async () => {
+    // This test verifies that output processors (like TraceIdInjector for Braintrust)
+    // are applied to messages saved during network execution.
+    // Issue: https://github.com/mastra-ai/mastra/issues/12300
+
+    const savedMessages: any[] = [];
+    const memory = new MockMemory();
+
+    // Intercept saveMessages to capture all saved messages
+    const originalSaveMessages = memory.saveMessages.bind(memory);
+    memory.saveMessages = async (params: any) => {
+      savedMessages.push(...params.messages);
+      return originalSaveMessages(params);
+    };
+
+    // Create an output processor that adds traceId to assistant messages
+    // (similar to the TraceIdInjector from the issue)
+    const traceIdProcessor = {
+      id: 'trace-id-injector',
+      name: 'Trace ID Injector',
+      processOutputResult: ({ messages }: { messages: any[] }) => {
+        return messages.map((msg: any) => {
+          if (msg.role === 'assistant') {
+            return {
+              ...msg,
+              content: {
+                ...msg.content,
+                metadata: {
+                  ...msg.content?.metadata,
+                  traceId: 'test-trace-id-12300',
+                },
+              },
+            };
+          }
+          return msg;
+        });
+      },
+    };
+
+    // Create a simple sub-agent
+    const subAgentMockModel = new MockLanguageModelV2({
+      doGenerate: async () => ({
+        rawCall: { rawPrompt: null, rawSettings: {} },
+        finishReason: 'stop',
+        usage: { inputTokens: 10, outputTokens: 20, totalTokens: 30 },
+        content: [{ type: 'text', text: 'Sub-agent response' }],
+        warnings: [],
+      }),
+      doStream: async () => ({
+        stream: convertArrayToReadableStream([
+          { type: 'stream-start', warnings: [] },
+          { type: 'response-metadata', id: 'id-0', modelId: 'mock-model-id', timestamp: new Date(0) },
+          { type: 'text-delta', id: 'id-0', delta: 'Sub-agent response' },
+          { type: 'finish', finishReason: 'stop', usage: { inputTokens: 10, outputTokens: 20, totalTokens: 30 } },
+        ]),
+      }),
+    });
+
+    const subAgent = new Agent({
+      id: 'subAgent',
+      name: 'Sub Agent',
+      description: 'A sub-agent for testing',
+      instructions: 'Do the task.',
+      model: subAgentMockModel,
+    });
+
+    // Routing agent selects sub-agent, then marks complete
+    const routingSelectAgent = JSON.stringify({
+      primitiveId: 'subAgent',
+      primitiveType: 'agent',
+      prompt: 'Do the task',
+      selectionReason: 'Sub-agent can handle this',
+    });
+
+    const completionResponse = JSON.stringify({
+      isComplete: true,
+      finalResult: 'Task completed',
+      completionReason: 'Sub-agent completed the request',
+    });
+
+    let routingCallCount = 0;
+    const routingMockModel = new MockLanguageModelV2({
+      doGenerate: async () => {
+        routingCallCount++;
+        const text = routingCallCount === 1 ? routingSelectAgent : completionResponse;
+        return {
+          rawCall: { rawPrompt: null, rawSettings: {} },
+          finishReason: 'stop',
+          usage: { inputTokens: 10, outputTokens: 20, totalTokens: 30 },
+          content: [{ type: 'text', text }],
+          warnings: [],
+        };
+      },
+      doStream: async () => {
+        routingCallCount++;
+        const text = routingCallCount === 1 ? routingSelectAgent : completionResponse;
+        return {
+          stream: convertArrayToReadableStream([
+            { type: 'stream-start', warnings: [] },
+            { type: 'response-metadata', id: 'id-0', modelId: 'mock-model-id', timestamp: new Date(0) },
+            { type: 'text-delta', id: 'id-0', delta: text },
+            { type: 'finish', finishReason: 'stop', usage: { inputTokens: 10, outputTokens: 20, totalTokens: 30 } },
+          ]),
+        };
+      },
+    });
+
+    // Create network agent with the output processor
+    const networkAgent = new Agent({
+      id: 'network-agent-with-processor',
+      name: 'Network Agent with Output Processor',
+      instructions: 'Delegate tasks to sub-agents.',
+      model: routingMockModel,
+      agents: { subAgent },
+      memory,
+      outputProcessors: [traceIdProcessor],
+    });
+
+    const anStream = await networkAgent.network('Do the task', {
+      memory: {
+        thread: 'test-thread-output-processors',
+        resource: 'test-resource-output-processors',
+      },
+    });
+
+    // Consume the stream
+    for await (const _chunk of anStream) {
+      // Process stream
+    }
+
+    // Verify that at least some messages were saved
+    expect(savedMessages.length).toBeGreaterThan(0);
+
+    // Find assistant messages saved during network execution
+    const assistantMessages = savedMessages.filter((msg: any) => msg.role === 'assistant');
+    expect(assistantMessages.length).toBeGreaterThan(0);
+
+    // The key assertion: output processors should have been applied,
+    // so assistant messages should have the traceId in their metadata
+    const messagesWithTraceId = assistantMessages.filter(
+      (msg: any) => msg.content?.metadata?.traceId === 'test-trace-id-12300',
+    );
+
+    // This assertion will FAIL if output processors are not applied to saved messages
+    expect(
+      messagesWithTraceId.length,
+      'Output processors should be applied to assistant messages saved during network execution. ' +
+        'Expected at least one assistant message to have traceId in metadata.',
+    ).toBeGreaterThan(0);
+  });
+});