fix: propagate requestContext to workflow in networkLoop (#12379)

## Description

Fixed issue #12330 where requestContext was not being propagated to the
internal workflow's stream() and resumeStream() calls in networkLoop().
This caused workflow_run spans to lack metadata (userId, resourceId),
breaking observability pipelines that rely on span metadata for billing,
analytics, and audit logging.

The fix adds requestContext to both run.stream() and run.resumeStream()
calls when creating MastraAgentNetworkStream.

## Related Issue(s)

Fixes #12330

## 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

- [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
-->
## Summary by CodeRabbit

* **Bug Fixes**
* Propagates request context across network workflows so tool executions
inherit user and resource metadata; workflow run spans now include user
and resource identifiers for improved tracing and auditability.
  * Stream resumption consistently applies the request context.

* **Tests**
* Added coverage verifying request context propagation through network
workflows and tools.

* **Documentation**
* Changelog updated to document the fix and observability improvements.

<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: graysonhicks

.changeset/deep-laws-sort.md

@@ -0,0 +1,5 @@
+---
+'@mastra/core': patch
+---
+
+Fixed agent.network() to properly pass requestContext to workflow runs. Workflow execution now includes user metadata (userId, resourceId) for observability and analytics. (Fixes #12330)

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

@@ -5621,3 +5621,89 @@ describe('Agent - network - output processors', () => {
     ).toBeGreaterThan(0);
   });
 });
+
+describe('Agent - network - requestContext propagation (issue #12330)', () => {
+  it('should propagate requestContext to tools executed within the network', async () => {
+    const memory = new MockMemory();
+    const capturedRequestContext: { userId?: string; resourceId?: string } = {};
+
+    const contextCaptureTool = createTool({
+      id: 'context-capture-tool-12330',
+      description: 'A tool that captures requestContext values for testing',
+      inputSchema: z.object({ message: z.string() }),
+      execute: async ({ message }, context) => {
+        capturedRequestContext.userId = context?.requestContext?.get('userId') as string | undefined;
+        capturedRequestContext.resourceId = context?.requestContext?.get('resourceId') as string | undefined;
+        return { result: `Captured for: ${message}` };
+      },
+    });
+
+    const routingSelectTool = JSON.stringify({
+      primitiveId: 'context-capture-tool-12330',
+      primitiveType: 'tool',
+      prompt: JSON.stringify({ message: 'test' }),
+      selectionReason: 'Testing requestContext propagation',
+    });
+
+    const completionResponse = JSON.stringify({
+      isComplete: true,
+      finalResult: 'Done',
+      completionReason: 'Tool executed',
+    });
+
+    let callCount = 0;
+    const mockModel = new MockLanguageModelV2({
+      doGenerate: async () => {
+        callCount++;
+        const text = callCount === 1 ? routingSelectTool : completionResponse;
+        return {
+          rawCall: { rawPrompt: null, rawSettings: {} },
+          finishReason: 'stop',
+          usage: { inputTokens: 10, outputTokens: 20, totalTokens: 30 },
+          content: [{ type: 'text', text }],
+          warnings: [],
+        };
+      },
+      doStream: async () => {
+        callCount++;
+        const text = callCount === 1 ? routingSelectTool : 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 } },
+          ]),
+        };
+      },
+    });
+
+    const networkAgent = new Agent({
+      id: 'test-agent-12330',
+      name: 'RequestContext Test Agent',
+      instructions: 'Use the context-capture-tool-12330 when asked.',
+      model: mockModel,
+      tools: { 'context-capture-tool-12330': contextCaptureTool },
+      memory,
+    });
+
+    const requestContext = new RequestContext<{ userId: string; resourceId: string }>();
+    requestContext.set('userId', 'network-user-12330');
+    requestContext.set('resourceId', 'network-resource-12330');
+
+    const anStream = await networkAgent.network('Test requestContext propagation', {
+      requestContext,
+      memory: {
+        thread: 'test-thread-12330',
+        resource: 'test-resource-12330',
+      },
+    });
+
+    for await (const _chunk of anStream) {
+      // consume
+    }
+
+    expect(capturedRequestContext.userId).toBe('network-user-12330');
+    expect(capturedRequestContext.resourceId).toBe('network-resource-12330');
+  });
+});

packages/core/src/loop/network/index.ts

@@ -2260,6 +2260,7 @@ export async function networkLoop<OUTPUT = undefined>({
       if (resumeDataToUse) {
         return run.resumeStream({
           resumeData: resumeDataToUse,
+          requestContext,
         }).fullStream;
       }
       return run.stream({
@@ -2274,6 +2275,7 @@ export async function networkLoop<OUTPUT = undefined>({
           isOneOff: false,
           verboseIntrospection: true,
         },
+        requestContext,
       }).fullStream;
     },
   });