fix(agent): pass toolCallId in context.agent for network tool execution (#10951)

**Critical Issue**: When tools are executed through the agent network,
the `context.agent.toolCallId` property is **undefined** despite being
required by the TypeScript type definitions. This creates a type safety
gap where the runtime behavior does not match the type contract.

### Type Definition vs Implementation Mismatch

The `AgentToolExecutionContext` type (from
`packages/core/src/tools/types.ts`) defines toolCallId as a required
string property:

```typescript
export interface AgentToolExecutionContext {
  toolCallId: string;        // ← Required, non-optional
  messages: any[];
  threadId?: string;
  resourceId?: string;
}
```

However, when tools execute through the network loop, `toolCallId` was
never passed to the context, violating the type contract and leaving
tools without access to a critical identifier.

### The Fix

This PR brings the runtime implementation into alignment with TypeScript
type definitions by passing the `toolCallId` generated during network
tool execution through to `context.agent`. Tools can now reliably
access:
- `context.agent.toolCallId` - Unique identifier for this tool call
- `context.agent.threadId` - Memory thread identifier
- `context.agent.resourceId` - Memory resource identifier

All three properties now properly propagate through network execution,
matching their type definitions.

## Related Issue(s)

Brings runtime implementation into alignment with type definitions for
AgentToolExecutionContext

## 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 made corresponding changes to the documentation (if
applicable)
- [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

* **Tests**
* Added validation tests to confirm tools receive a complete agent
context (including call identifiers) during network execution.

* **Improvements**
* Tools now receive the call identifier (toolCallId) in their execution
context for improved tracking and visibility at runtime.

* **Chores**
  * Recorded a patch changeset documenting the fix.

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

.changeset/fix-toolcallid-propagation.md

@@ -0,0 +1,5 @@
+---
+'@mastra/core': patch
+---
+
+Fix toolCallId propagation in agent network tool execution. The toolCallId property was undefined at runtime despite being required by TypeScript type definitions in AgentToolExecutionContext. Now properly passes the toolCallId through to the tool's context during network tool execution.

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

@@ -1,5 +1,6 @@
 import { openai } from '@ai-sdk/openai-v5';
-import { describe, expect, it } from 'vitest';
+import { MockLanguageModelV2, convertArrayToReadableStream } from 'ai-v5/test';
+import { describe, expect, it, vi } from 'vitest';
 import { z } from 'zod';
 import { MastraError } from '../error';
 import { MockMemory } from '../memory/mock';
@@ -697,3 +698,86 @@ describe('Agent - network - updateWorkingMemory', () => {
     expect(thread?.resourceId).toBe(resourceId);
   });
 }, 120e3);
+
+describe('Agent - network - tool context validation', () => {
+  it('should pass toolCallId, threadId, and resourceId in context.agent when network executes a tool', async () => {
+    const mockExecute = vi.fn(async (_inputData, _context) => {
+      return { result: 'context captured' };
+    });
+
+    const tool = createTool({
+      id: 'context-check-tool',
+      description: 'Tool to validate context.agent properties from network',
+      inputSchema: z.object({
+        message: z.string(),
+      }),
+      execute: mockExecute,
+    });
+
+    // Mock model returns routing agent selection schema
+    // The network's routing agent uses structuredOutput expecting: { primitiveId, primitiveType, prompt, selectionReason }
+    const routingResponse = JSON.stringify({
+      primitiveId: 'tool',
+      primitiveType: 'tool',
+      prompt: JSON.stringify({ message: 'validate context' }),
+      selectionReason: 'Test context propagation through network',
+    });
+
+    const mockModel = new MockLanguageModelV2({
+      doGenerate: async () => ({
+        rawCall: { rawPrompt: null, rawSettings: {} },
+        finishReason: 'stop',
+        usage: { inputTokens: 10, outputTokens: 20, totalTokens: 30 },
+        content: [{ type: 'text', text: routingResponse }],
+        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: routingResponse },
+          { type: 'finish', finishReason: 'stop', usage: { inputTokens: 10, outputTokens: 20, totalTokens: 30 } },
+        ]),
+      }),
+    });
+
+    const memory = new MockMemory();
+
+    const agent = new Agent({
+      id: 'context-network-agent',
+      name: 'Context Test Network',
+      instructions: 'Use the context-check-tool to validate context properties.',
+      model: mockModel,
+      tools: { tool },
+      memory,
+    });
+
+    const threadId = 'context-test-thread';
+    const resourceId = 'context-test-resource';
+
+    const anStream = await agent.network('Validate context by using the context-check-tool', {
+      memory: {
+        thread: threadId,
+        resource: resourceId,
+      },
+    });
+
+    // Consume the stream to trigger tool execution through network
+    for await (const _chunk of anStream) {
+      // Stream events are processed
+    }
+
+    // Verify the tool was called with context containing toolCallId, threadId, and resourceId
+    expect(mockExecute).toHaveBeenCalled();
+    expect(mockExecute).toHaveBeenCalledWith(
+      expect.objectContaining({ message: 'validate context' }),
+      expect.objectContaining({
+        agent: expect.objectContaining({
+          toolCallId: expect.any(String),
+          threadId,
+          resourceId,
+        }),
+      }),
+    );
+  });
+});

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

@@ -957,6 +957,7 @@ export async function createNetworkLoop({
           mastra: agent.getMastraInstance(),
           agent: {
             resourceId: initData.threadResourceId || networkName,
+            toolCallId,
             threadId: initData.threadId,
           },
           runId,