fix: prevent response truncation for complex multi-step queries

emergent2api/backends/jobs.py

@@ -65,7 +65,10 @@ class JobsBackend(EmergentBackend):
         has_received_anything = False
         job_completed = False
         last_change_time = 0.0
-        max_wait_cycles = 900
+        last_activity_time = 0.0
+        prev_item_count = 0
+        prev_max_step = -1
+        max_wait_cycles = 1200
         start_time = time.time()
 
         await asyncio.sleep(3.0)
@@ -84,6 +87,23 @@ class JobsBackend(EmergentBackend):
                 if status in ("completed", "done", "finished"):
                     job_completed = True
 
+            cur_item_count = len(data_items)
+            cur_max_step = -1
+            for item in data_items:
+                payload = item.get("traj_payload") or {}
+                step = payload.get("step_num", -1)
+                if isinstance(step, (int, float)) and step > cur_max_step:
+                    cur_max_step = int(step)
+
+            activity_changed = (
+                cur_item_count > prev_item_count
+                or cur_max_step > prev_max_step
+            )
+            if activity_changed:
+                last_activity_time = time.time()
+            prev_item_count = cur_item_count
+            prev_max_step = cur_max_step
+
             current_full_text = ""
             current_thinking = ""
             for item in data_items:
@@ -108,6 +128,7 @@ class JobsBackend(EmergentBackend):
                 confirmed_end = False
                 has_received_anything = True
                 last_change_time = time.time()
+                last_activity_time = time.time()
                 if stream and delta:
                     yield {"type": "text", "content": delta}
             else:
@@ -117,22 +138,38 @@ class JobsBackend(EmergentBackend):
                     logger.info("Stream completed (job status=completed)")
                     break
 
-                stable_secs = time.time() - last_change_time if last_change_time else 0
+                now = time.time()
+                text_stable_secs = now - last_change_time if last_change_time else 0
+                activity_idle_secs = now - last_activity_time if last_activity_time else 0
+
+                if has_received_anything and full_text and activity_idle_secs >= 90.0:
+                    if not confirmed_end:
+                        logger.debug(f"No activity for {activity_idle_secs:.0f}s, confirming end...")
+                        confirmed_end = True
+                        await asyncio.sleep(10.0)
+                        continue
+                    logger.info(f"Stream completed (idle {activity_idle_secs:.0f}s, {len(full_text)} chars)")
+                    break
+
                 text_len = len(full_text)
                 if text_len < 50:
-                    stable_limit = 15.0
+                    stable_limit = 20.0
                 elif text_len < 500:
-                    stable_limit = 25.0
+                    stable_limit = 40.0
                 else:
-                    stable_limit = 45.0
-                if has_received_anything and full_text and stable_secs >= stable_limit:
+                    stable_limit = 90.0
+
+                if has_received_anything and full_text and text_stable_secs >= stable_limit:
+                    if activity_idle_secs < 60.0:
+                        logger.debug(f"Text stable {text_stable_secs:.0f}s but agent still active (idle {activity_idle_secs:.0f}s), waiting...")
+                        await asyncio.sleep(3.0)
+                        continue
                     if not confirmed_end:
-                        logger.debug(f"Content stable for {stable_secs:.0f}s (len={text_len}), confirming...")
+                        logger.debug(f"Text stable {text_stable_secs:.0f}s + agent idle {activity_idle_secs:.0f}s, confirming...")
                         confirmed_end = True
-                        confirm_wait = 5.0 if text_len < 200 else 10.0
-                        await asyncio.sleep(confirm_wait)
+                        await asyncio.sleep(10.0)
                         continue
-                    logger.info(f"Stream completed (stable {stable_secs:.0f}s, {text_len} chars)")
+                    logger.info(f"Stream completed (stable {text_stable_secs:.0f}s, {text_len} chars)")
                     break
 
             await self._dynamic_sleep(consecutive_unchanged, has_received_anything)