Fix loop detection: don't count looped-on agent's runs as progress

When Coordinator keeps picking the same agent A and A keeps running, A's
own completions were bumping _progress_counter. Loop detection compares
the counter snapshot taken at the previous identical Coordinator pick
against the current value; if it changed, the streak was reset to 1. So
the 3-strike threshold was never reached and the Coordinator->A->A
pattern ran until max_rounds.

Now we only treat a non-Coordinator completion as 'progress' when the
completing agent is different from the agent the Coordinator is
currently latching onto (_last_coordinator_selection[0]). A different
agent stepping in still resets the streak; A repeating itself does not.

Adds two regression tests covering both cases. Also updates an existing
termination test whose name described 'other agent makes progress' but
actually used the same agent, hard-coding the buggy semantics.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Prachig-Microsoft

src/processor/src/libs/agent_framework/groupchat_orchestrator.py

@@ -1018,8 +1018,27 @@ async def _complete_agent_response(
         # Mark progress on any non-Coordinator completion. This is used to ensure loop
         # detection only triggers when the Coordinator is repeating itself *and* the
         # rest of the conversation is not advancing.
+        #
+        # IMPORTANT: we must NOT count the looped-on agent's own runs as "progress".
+        # If we did, then the pattern "Coordinator picks A -> A runs -> Coordinator
+        # picks A -> A runs -> ..." would keep bumping the progress counter, which
+        # would reset the loop-detection streak on every check, and the streak would
+        # never grow past 1. The loop would then never be detected.
+        #
+        # Real progress means a DIFFERENT agent ran since the last identical Coordinator
+        # selection. So we only increment when the completing agent is not the one the
+        # Coordinator is currently latching onto.
         if agent_name != self.coordinator_name:
-            self._progress_counter += 1
+            last_selected = (
+                self._last_coordinator_selection[0]
+                if self._last_coordinator_selection
+                else None
+            )
+            if (
+                last_selected is None
+                or agent_name.lower() != last_selected.lower()
+            ):
+                self._progress_counter += 1
 
         # Detect manager termination signal (finish=true) from Coordinator.
         # NOTE: The underlying GroupChatBuilder does not automatically stop on finish,

src/processor/src/tests/unit/libs/agent_framework/test_groupchat_orchestrator_internals.py

@@ -700,6 +700,92 @@ def _select(participant: str, instruction: str = "do"):
 
         assert orch._forced_termination_requested is True
 
+    def test_loop_breaker_triggered_when_looped_agent_runs_between_selections(
+        self,
+    ):
+        """Regression: when Coordinator keeps picking the same agent, that agent's
+        own runs MUST NOT count as progress, or the streak resets and the loop
+        never breaks.
+        """
+        orch = _make_orch()
+        orch._conversation = []
+
+        def _select(participant: str, instruction: str = "do"):
+            orch._current_agent_response = [
+                json.dumps(
+                    {
+                        "selected_participant": participant,
+                        "instruction": instruction,
+                        "finish": False,
+                        "final_message": "",
+                    }
+                )
+            ]
+            orch._current_agent_start_time = datetime.now()
+
+        def _agent_runs(name: str, text: str = "ok"):
+            orch._current_agent_response = [text]
+            orch._current_agent_start_time = datetime.now()
+
+        # Simulate production sequence: Coordinator picks A, then A runs,
+        # then Coordinator picks A again, then A runs, etc.
+        _select("A")
+        _run(orch._complete_agent_response("Coordinator", None))
+        _agent_runs("A")
+        _run(orch._complete_agent_response("A", None))
+        _select("A")
+        _run(orch._complete_agent_response("Coordinator", None))
+        _agent_runs("A")
+        _run(orch._complete_agent_response("A", None))
+        _select("A")
+        _run(orch._complete_agent_response("Coordinator", None))
+
+        assert orch._forced_termination_requested is True
+
+    def test_loop_breaker_resets_when_different_agent_responds(self):
+        """If a different agent responds between identical Coordinator selections,
+        treat that as real progress and reset the streak.
+        """
+        orch = _make_orch()
+        orch._conversation = []
+
+        def _select(participant: str, instruction: str = "do"):
+            orch._current_agent_response = [
+                json.dumps(
+                    {
+                        "selected_participant": participant,
+                        "instruction": instruction,
+                        "finish": False,
+                        "final_message": "",
+                    }
+                )
+            ]
+            orch._current_agent_start_time = datetime.now()
+
+        def _agent_runs(name: str, text: str = "ok"):
+            orch._current_agent_response = [text]
+            orch._current_agent_start_time = datetime.now()
+
+        # Sequence: A, A, B, A, A (a different agent B interrupts -> streak resets)
+        _select("A")
+        _run(orch._complete_agent_response("Coordinator", None))
+        _agent_runs("A")
+        _run(orch._complete_agent_response("A", None))
+        _select("A")
+        _run(orch._complete_agent_response("Coordinator", None))
+        _agent_runs("B")
+        _run(orch._complete_agent_response("B", None))
+        _select("A")
+        _run(orch._complete_agent_response("Coordinator", None))
+        _agent_runs("A")
+        _run(orch._complete_agent_response("A", None))
+        _select("A")
+        _run(orch._complete_agent_response("Coordinator", None))
+
+        # Only 2 consecutive A selections without progress (one streak of 2
+        # before B reset it, one streak of 2 after). Loop NOT detected.
+        assert orch._forced_termination_requested is False
+
 
 # -----------------------------------------------------------------------------
 # _build_groupchat

src/processor/src/tests/unit/libs/agent_framework/test_groupchat_orchestrator_termination.py

@@ -113,9 +113,9 @@ def _agent_reply(text: str = "ok"):
         _coordinator_select("Chief Architect")
         await orch._complete_agent_response("Coordinator", callback=None)
 
-        # 2) The participant responds (progress).
+        # 2) A DIFFERENT participant responds (real progress, not the looped-on one).
         _agent_reply("progress")
-        await orch._complete_agent_response("Chief Architect", callback=None)
+        await orch._complete_agent_response("AKS Expert", callback=None)
 
         # 3) Coordinator repeats the same selection twice.
         _coordinator_select("Chief Architect")