diff --git a/dotnet/src/Microsoft.Agents.AI.Workflows/Specialized/AIAgentUnservicedRequestsCollector.cs b/dotnet/src/Microsoft.Agents.AI.Workflows/Specialized/AIAgentUnservicedRequestsCollector.cs
index 7e4f8c8c9d4..730f7510ea1 100644
--- a/dotnet/src/Microsoft.Agents.AI.Workflows/Specialized/AIAgentUnservicedRequestsCollector.cs
+++ b/dotnet/src/Microsoft.Agents.AI.Workflows/Specialized/AIAgentUnservicedRequestsCollector.cs
@@ -14,8 +14,9 @@ internal sealed class AIAgentUnservicedRequestsCollector(AIContentExternalHandle
 {
     private readonly Dictionary<string, ToolApprovalRequestContent> _userInputRequests = [];
     private readonly Dictionary<string, FunctionCallContent> _functionCalls = [];
+    private readonly List<string> _displacedRequestIds = [];
 
-    public Task SubmitAsync(IWorkflowContext context, CancellationToken cancellationToken)
+    public async Task SubmitAsync(IWorkflowContext context, CancellationToken cancellationToken)
     {
         Task userInputTask = userInputHandler != null && this._userInputRequests.Count > 0
                            ? userInputHandler.ProcessRequestContentsAsync(this._userInputRequests, context, cancellationToken)
@@ -25,7 +26,17 @@ public Task SubmitAsync(IWorkflowContext context, CancellationToken cancellation
                               ? functionCallHandler.ProcessRequestContentsAsync(this._functionCalls, context, cancellationToken)
                               : Task.CompletedTask;
 
-        return Task.WhenAll(userInputTask, functionCallTask);
+        await Task.WhenAll(userInputTask, functionCallTask).ConfigureAwait(false);
+
+        if (this._displacedRequestIds.Count > 0)
+        {
+            // A different request reusing an outstanding ID cannot be serviced alongside the one already
+            // recorded under it, so report the ones that were dropped rather than losing them silently.
+            await context.AddEventAsync(
+                new WorkflowWarningEvent(
+                    $"Ignored request content reusing an outstanding request ID ([{string.Join(", ", this._displacedRequestIds)}])."),
+                cancellationToken).ConfigureAwait(false);
+        }
     }
 
     public void ProcessAgentResponseUpdate(AgentResponseUpdate update, Func<FunctionCallContent, bool>? functionCallFilter = null)
@@ -34,19 +45,34 @@ public void ProcessAgentResponseUpdate(AgentResponseUpdate update, Func<Function
     public void ProcessAgentResponse(AgentResponse response)
         => this.ProcessAIContents(response.Messages.SelectMany(message => message.Contents));
 
+    /// <summary>
+    /// Records the requests these contents leave unserviced, and clears the ones they answer.
+    /// </summary>
+    /// <remarks>
+    /// The first content seen for a request ID is the one kept, matching
+    /// <see cref="AIContentExternalHandler{TRequestContent, TResponseContent}"/>, which treats a repeat as an
+    /// idempotent re-emission, and <c>ApprovalResponseBindingChatClient</c>, which binds a response against the
+    /// first request recorded for the ID. A later content that is not the same request is reported by
+    /// <see cref="SubmitAsync"/>.
+    /// </remarks>
     public void ProcessAIContents(IEnumerable<AIContent> contents, Func<FunctionCallContent, bool>? functionCallFilter = null)
     {
         foreach (AIContent content in contents)
         {
             if (content is ToolApprovalRequestContent userInputRequest)
             {
-                if (this._userInputRequests.ContainsKey(userInputRequest.RequestId))
+                if (this._userInputRequests.TryGetValue(userInputRequest.RequestId, out ToolApprovalRequestContent? recordedRequest))
                 {
-                    throw new InvalidOperationException($"ToolApprovalRequestContent with duplicate RequestId: {userInputRequest.RequestId}");
+                    // The approval's ID is derived from the call it guards, so a different call under the
+                    // same ID is a different request rather than a re-emission of this one.
+                    this.NoteDisplacedRequest(
+                        userInputRequest.RequestId,
+                        string.Equals(recordedRequest.ToolCall.CallId, userInputRequest.ToolCall.CallId, StringComparison.Ordinal));
+                }
+                else
+                {
+                    this._userInputRequests.Add(userInputRequest.RequestId, userInputRequest);
                 }
-
-                // It is an error to simultaneously have multiple outstanding user input requests with the same ID.
-                this._userInputRequests.Add(userInputRequest.RequestId, userInputRequest);
             }
             else if (content is ToolApprovalResponseContent userInputResponse)
             {
@@ -61,12 +87,18 @@ public void ProcessAIContents(IEnumerable<AIContent> contents, Func<FunctionCall
                 // possibility 2: this will not be handled inline by the agent abstraction
                 if (functionCallFilter == null || functionCallFilter(functionCall))
                 {
-                    if (this._functionCalls.ContainsKey(functionCall.CallId))
+                    if (this._functionCalls.TryGetValue(functionCall.CallId, out FunctionCallContent? recordedCall))
                     {
-                        throw new InvalidOperationException($"FunctionCallContent with duplicate CallId: {functionCall.CallId}");
+                        // A same-named call under one ID is taken to be a re-emission. Comparing arguments
+                        // instead would report a legitimate re-emission whose arguments were rebuilt.
+                        this.NoteDisplacedRequest(
+                            functionCall.CallId,
+                            string.Equals(recordedCall.Name, functionCall.Name, StringComparison.Ordinal));
+                    }
+                    else
+                    {
+                        this._functionCalls.Add(functionCall.CallId, functionCall);
                     }
-
-                    this._functionCalls.Add(functionCall.CallId, functionCall);
                 }
             }
             else if (content is FunctionResultContent functionResult)
@@ -75,4 +107,12 @@ public void ProcessAIContents(IEnumerable<AIContent> contents, Func<FunctionCall
             }
         }
     }
+
+    private void NoteDisplacedRequest(string requestId, bool isSameRequest)
+    {
+        if (!isSameRequest && !this._displacedRequestIds.Contains(requestId, StringComparer.Ordinal))
+        {
+            this._displacedRequestIds.Add(requestId);
+        }
+    }
 }
diff --git a/dotnet/src/Microsoft.Agents.AI.Workflows/Specialized/HandoffAgentExecutor.cs b/dotnet/src/Microsoft.Agents.AI.Workflows/Specialized/HandoffAgentExecutor.cs
index 50a6871aa2c..508cfe8fd2d 100644
--- a/dotnet/src/Microsoft.Agents.AI.Workflows/Specialized/HandoffAgentExecutor.cs
+++ b/dotnet/src/Microsoft.Agents.AI.Workflows/Specialized/HandoffAgentExecutor.cs
@@ -445,7 +445,13 @@ private async ValueTask<AgentInvocationResult> InvokeAgentAsync(IEnumerable<Chat
             bool CollectHandoffRequestsFilter(FunctionCallContent candidateHandoffRequest)
             {
                 bool isHandoffRequest = this._handoffFunctionNames.Contains(candidateHandoffRequest.Name);
-                if (isHandoffRequest)
+
+                // A stream that re-emits one handoff call must not read as two competing handoffs. The name is
+                // compared alongside the ID so that two different targets sharing an ID stay visible below.
+                if (isHandoffRequest
+                    && !candidateRequests.Any(candidate =>
+                        string.Equals(candidate.Request.CallId, candidateHandoffRequest.CallId, StringComparison.Ordinal)
+                        && string.Equals(candidate.Request.Name, candidateHandoffRequest.Name, StringComparison.Ordinal)))
                 {
                     candidateRequests.Add((candidateHandoffRequest, update.ResponseId));
                 }
diff --git a/dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/AIAgentHostExecutorTests.cs b/dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/AIAgentHostExecutorTests.cs
index e5c45ebe4e0..4e6210671f1 100644
--- a/dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/AIAgentHostExecutorTests.cs
+++ b/dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/AIAgentHostExecutorTests.cs
@@ -289,6 +289,83 @@ List<object> ExtractAndValidateRequestContents<TRequest>() where TRequest : AICo
         lastResponseEvent.Response.Text.Should().Be("Done");
     }
 
+    [Fact]
+    public async Task Test_AgentHostExecutor_ReusedApprovalRequestIdIsReportedAsync()
+    {
+        // Arrange
+        const string RequestId = "shared-request-id";
+        TestRunContext testContext = new();
+        RequestEmittingAgent agent = new(
+        [
+            new ToolApprovalRequestContent(RequestId, new McpServerToolCallContent("first-call", "firstTool", "http://localhost")),
+            new ToolApprovalRequestContent(RequestId, new McpServerToolCallContent("second-call", "secondTool", "http://localhost")),
+        ]);
+        AIAgentHostExecutor executor = new(agent, new() { InterceptUserInputRequests = false, EmitAgentUpdateEvents = true });
+        testContext.ConfigureExecutor(executor);
+
+        // Act
+        await executor.TakeTurnAsync(new(), testContext.BindWorkflowContext(executor.Id));
+
+        // Assert
+        WorkflowWarningEvent warning = testContext.Events.OfType<WorkflowWarningEvent>().Should().ContainSingle().Which;
+        warning.Data.Should().BeOfType<string>().Which.Should().Contain(RequestId);
+
+        ToolApprovalRequestContent raised =
+            testContext.ExternalRequests.Should().ContainSingle().Which.Data.As<ToolApprovalRequestContent>()
+                       .Should().NotBeNull().And.Subject.As<ToolApprovalRequestContent>();
+        raised.ToolCall.CallId.Should().Be("first-call", "the first request recorded for an ID is the one raised");
+    }
+
+    [Fact]
+    public async Task Test_AgentHostExecutor_ReusedCallIdIsReportedAsync()
+    {
+        // Arrange
+        const string CallId = "shared-call-id";
+        TestRunContext testContext = new();
+        RequestEmittingAgent agent = new(
+        [
+            new FunctionCallContent(CallId, "firstFunction"),
+            new FunctionCallContent(CallId, "secondFunction"),
+        ]);
+        AIAgentHostExecutor executor = new(agent, new() { InterceptUnterminatedFunctionCalls = false, EmitAgentUpdateEvents = true });
+        testContext.ConfigureExecutor(executor);
+
+        // Act
+        await executor.TakeTurnAsync(new(), testContext.BindWorkflowContext(executor.Id));
+
+        // Assert
+        WorkflowWarningEvent warning = testContext.Events.OfType<WorkflowWarningEvent>().Should().ContainSingle().Which;
+        warning.Data.Should().BeOfType<string>().Which.Should().Contain(CallId);
+
+        FunctionCallContent raised =
+            testContext.ExternalRequests.Should().ContainSingle().Which.Data.As<FunctionCallContent>()
+                       .Should().NotBeNull().And.Subject.As<FunctionCallContent>();
+        raised.Name.Should().Be("firstFunction", "the first request recorded for an ID is the one raised");
+    }
+
+    [Fact]
+    public async Task Test_AgentHostExecutor_ReEmittedRequestIsNotReportedAsync()
+    {
+        // Arrange
+        const string CallId = "re-emitted-call-id";
+        TestRunContext testContext = new();
+        RequestEmittingAgent agent = new(
+        [
+            new FunctionCallContent(CallId, "sameFunction"),
+            new FunctionCallContent(CallId, "sameFunction"),
+        ]);
+        AIAgentHostExecutor executor = new(agent, new() { InterceptUnterminatedFunctionCalls = false, EmitAgentUpdateEvents = true });
+        testContext.ConfigureExecutor(executor);
+
+        // Act
+        await executor.TakeTurnAsync(new(), testContext.BindWorkflowContext(executor.Id));
+
+        // Assert
+        testContext.Events.OfType<WorkflowWarningEvent>()
+                   .Should().BeEmpty("the same call repeated across updates is one request, not a displaced one");
+        testContext.ExternalRequests.Should().ContainSingle();
+    }
+
     #region FilterForwardableMessages tests
 
     /// <summary>
diff --git a/dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/HandoffAgentExecutorTests.cs b/dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/HandoffAgentExecutorTests.cs
index 70f802399d6..16f3cc6a89b 100644
--- a/dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/HandoffAgentExecutorTests.cs
+++ b/dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/HandoffAgentExecutorTests.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
@@ -176,6 +177,101 @@ public async Task Test_HandoffAgentExecutor_ComposesWithHITLSubworkflowAsync()
                                                          testContext.BindWorkflowContext(executor.Id));
     }
 
+    /// <summary>
+    /// An agent that emits the workflow's handoff call once per update, modelling a stream that spreads one call
+    /// over several updates.
+    /// </summary>
+    private sealed class RepeatingHandoffAgent(int emissionCount, bool varyTarget = false) : AIAgent
+    {
+        private sealed class Session : AgentSession
+        {
+            public Session() { }
+        }
+
+        protected override ValueTask<AgentSession> CreateSessionCoreAsync(CancellationToken cancellationToken = default)
+            => new(new Session());
+
+        protected override ValueTask<AgentSession> DeserializeSessionCoreAsync(JsonElement serializedState, JsonSerializerOptions? jsonSerializerOptions = null, CancellationToken cancellationToken = default)
+            => new(new Session());
+
+        protected override ValueTask<JsonElement> SerializeSessionCoreAsync(AgentSession session, JsonSerializerOptions? jsonSerializerOptions = null, CancellationToken cancellationToken = default)
+            => default;
+
+        protected override Task<AgentResponse> RunCoreAsync(IEnumerable<ChatMessage> messages, AgentSession? session = null, AgentRunOptions? options = null, CancellationToken cancellationToken = default)
+            => this.RunStreamingAsync(messages, session, options, cancellationToken).ToAgentResponseAsync(cancellationToken);
+
+        protected override async IAsyncEnumerable<AgentResponseUpdate> RunCoreStreamingAsync(IEnumerable<ChatMessage> messages, AgentSession? session = null, AgentRunOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+        {
+            List<string> handoffFunctionNames =
+                [.. (options as ChatClientAgentRunOptions)?.ChatOptions?.Tools?
+                    .Where(tool => tool.Name.StartsWith("handoff_to_", StringComparison.Ordinal))
+                    .Select(tool => tool.Name) ?? []];
+
+            if (handoffFunctionNames.Count == 0)
+            {
+                throw new InvalidOperationException("No handoff tool was offered to the agent.");
+            }
+
+            for (int emission = 0; emission < emissionCount; emission++)
+            {
+                // Every emission reuses one call ID; only the target varies, and only when asked.
+                string handoffFunctionName = handoffFunctionNames[varyTarget ? emission % handoffFunctionNames.Count : 0];
+                yield return new AgentResponseUpdate(ChatRole.Assistant, [new FunctionCallContent("handoff-call", handoffFunctionName)]);
+            }
+        }
+    }
+
+    [Fact]
+    public async Task Test_HandoffAgentExecutor_RepeatedHandoffCallIsNotTreatedAsDuplicateAsync()
+    {
+        // Arrange
+        AIAgent handoffAgent = new RepeatingHandoffAgent(emissionCount: 2);
+        HandoffTarget handoff = new(new TestEchoAgent());
+
+        HandoffAgentExecutorOptions options = new(handoffInstructions: null,
+                                                  emitAgentResponseEvents: false,
+                                                  emitAgentResponseUpdateEvents: true,
+                                                  HandoffToolCallFilteringBehavior.None);
+        HandoffAgentExecutor executor = new(handoffAgent, [handoff], options);
+
+        TestRunContext runContext = await PrepareHandoffSharedStateAsync();
+        runContext.ConfigureExecutor(executor);
+        IWorkflowContext testContext = runContext.BindWorkflowContext(executor.Id);
+
+        // Act
+        await executor.HandleAsync(new HandoffState(new(true), null), testContext);
+
+        // Assert
+        runContext.Events.OfType<WorkflowWarningEvent>()
+                  .Should().BeEmpty("one handoff call re-emitted across updates is a single handoff request");
+    }
+
+    [Fact]
+    public async Task Test_HandoffAgentExecutor_DifferentTargetsSharingACallIdStillWarnAsync()
+    {
+        // Arrange
+        AIAgent handoffAgent = new RepeatingHandoffAgent(emissionCount: 2, varyTarget: true);
+        HandoffTarget firstHandoff = new(new TestEchoAgent("firstTarget"));
+        HandoffTarget secondHandoff = new(new TestEchoAgent("secondTarget"));
+
+        HandoffAgentExecutorOptions options = new(handoffInstructions: null,
+                                                  emitAgentResponseEvents: false,
+                                                  emitAgentResponseUpdateEvents: true,
+                                                  HandoffToolCallFilteringBehavior.None);
+        HandoffAgentExecutor executor = new(handoffAgent, [firstHandoff, secondHandoff], options);
+
+        TestRunContext runContext = await PrepareHandoffSharedStateAsync();
+        runContext.ConfigureExecutor(executor);
+        IWorkflowContext testContext = runContext.BindWorkflowContext(executor.Id);
+
+        // Act
+        await executor.HandleAsync(new HandoffState(new(true), null), testContext);
+
+        // Assert
+        runContext.Events.OfType<WorkflowWarningEvent>()
+                  .Should().ContainSingle("two different handoff targets remain two competing handoffs even under one call ID");
+    }
+
     [Fact]
     public async Task Test_HandoffAgentExecutor_PreservesExistingInstructionsAndToolsAsync()
     {
diff --git a/dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/WorkflowHostSmokeTests.cs b/dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/WorkflowHostSmokeTests.cs
index 92ebc5915d8..6d3d95bf752 100644
--- a/dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/WorkflowHostSmokeTests.cs
+++ b/dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/WorkflowHostSmokeTests.cs
@@ -34,7 +34,7 @@ public ExpectedException(string? message, Exception? innerException) : base(mess
 /// </summary>
 internal sealed class RequestEmittingAgent : AIAgent
 {
-    private readonly AIContent _requestContent;
+    private readonly IReadOnlyList<AIContent> _requestContents;
     private readonly bool _completeOnResponse;
 
     /// <summary>
@@ -48,8 +48,19 @@ internal sealed class RequestEmittingAgent : AIAgent
     /// where the agent processes the tool result and produces a final answer.
     /// </param>
     public RequestEmittingAgent(AIContent requestContent, bool completeOnResponse = false)
+        : this([requestContent], completeOnResponse)
     {
-        this._requestContent = requestContent;
+    }
+
+    /// <summary>
+    /// Creates a new <see cref="RequestEmittingAgent"/> that emits one update per content, modelling a stream
+    /// that spreads its request content over several updates.
+    /// </summary>
+    /// <param name="requestContents">The contents to emit, one update each.</param>
+    /// <param name="completeOnResponse">See the single-content constructor.</param>
+    public RequestEmittingAgent(IReadOnlyList<AIContent> requestContents, bool completeOnResponse = false)
+    {
+        this._requestContents = requestContents;
         this._completeOnResponse = completeOnResponse;
     }
 
@@ -80,7 +91,10 @@ protected override async IAsyncEnumerable<AgentResponseUpdate> RunCoreStreamingA
         else
         {
             // Emit the request content
-            yield return new AgentResponseUpdate(ChatRole.Assistant, [this._requestContent]);
+            foreach (AIContent requestContent in this._requestContents)
+            {
+                yield return new AgentResponseUpdate(ChatRole.Assistant, [requestContent]);
+            }
         }
     }
 }
@@ -385,6 +399,82 @@ public async Task Test_AsAgent_ToolApprovalRequestContentPreservedInRequestInfoA
         retrievedContent.RequestId.Should().EndWith($":{RequestId}");
     }
 
+    /// <summary>
+    /// Tests that a function call repeated across updates is raised once, keeping the first content seen,
+    /// instead of failing the run.
+    /// </summary>
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task Test_AsAgent_RepeatedFunctionCallIsCoalescedAsync(bool emitAgentUpdateEvents)
+    {
+        // Arrange
+        const string CallId = "repeated-call-id";
+        const string FunctionName = "testFunction";
+        RequestEmittingAgent requestAgent = new(
+        [
+            new FunctionCallContent(CallId, FunctionName, new Dictionary<string, object?> { ["first"] = 1 }),
+            new FunctionCallContent(CallId, FunctionName, new Dictionary<string, object?> { ["second"] = 2 }),
+        ]);
+        ExecutorBinding agentBinding = requestAgent.BindAsExecutor(
+            new AIAgentHostOptions { InterceptUnterminatedFunctionCalls = false, EmitAgentUpdateEvents = emitAgentUpdateEvents });
+        Workflow workflow = new WorkflowBuilder(agentBinding).Build();
+
+        // Act
+        List<AgentResponseUpdate> updates = await workflow.AsAIAgent("WorkflowAgent", includeExceptionDetails: true)
+                                                           .RunStreamingAsync(new ChatMessage(ChatRole.User, "Hello"))
+                                                           .ToListAsync();
+
+        // Assert
+        updates.SelectMany(update => update.Contents.OfType<ErrorContent>())
+               .Should().BeEmpty("a repeated call ID is one pending request, not a failure");
+
+        FunctionCallContent raised = updates
+            .Where(update => update.RawRepresentation is RequestInfoEvent)
+            .SelectMany(update => update.Contents.OfType<FunctionCallContent>())
+            .Should().ContainSingle()
+            .Which;
+
+        raised.CallId.Should().EndWith($":{CallId}");
+        raised.Arguments.Should().ContainKey("first", "the first content seen for a request ID is the one kept");
+        raised.Arguments.Should().NotContainKey("second");
+    }
+
+    /// <summary>
+    /// Tests that an approval request repeated across updates is raised once instead of failing the run.
+    /// </summary>
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task Test_AsAgent_RepeatedToolApprovalRequestIsCoalescedAsync(bool emitAgentUpdateEvents)
+    {
+        // Arrange
+        const string RequestId = "repeated-request-id";
+        McpServerToolCallContent mcpCall = new("call-id", "testToolName", "http://localhost");
+        RequestEmittingAgent requestAgent = new(
+        [
+            new ToolApprovalRequestContent(RequestId, mcpCall),
+            new ToolApprovalRequestContent(RequestId, mcpCall),
+        ]);
+        ExecutorBinding agentBinding = requestAgent.BindAsExecutor(
+            new AIAgentHostOptions { InterceptUserInputRequests = false, EmitAgentUpdateEvents = emitAgentUpdateEvents });
+        Workflow workflow = new WorkflowBuilder(agentBinding).Build();
+
+        // Act
+        List<AgentResponseUpdate> updates = await workflow.AsAIAgent("WorkflowAgent", includeExceptionDetails: true)
+                                                           .RunStreamingAsync(new ChatMessage(ChatRole.User, "Hello"))
+                                                           .ToListAsync();
+
+        // Assert
+        updates.SelectMany(update => update.Contents.OfType<ErrorContent>())
+               .Should().BeEmpty("a repeated request ID is one pending request, not a failure");
+
+        updates.Where(update => update.RawRepresentation is RequestInfoEvent)
+               .SelectMany(update => update.Contents.OfType<ToolApprovalRequestContent>())
+               .Should().ContainSingle()
+               .Which.RequestId.Should().EndWith($":{RequestId}");
+    }
+
     /// <summary>
     /// Tests the full roundtrip: workflow emits a request, external caller responds, workflow processes response.
     /// </summary>