Fix sse-starlette event-loop binding in streaming tests (#22)

Root cause:
  sse_starlette.sse.AppStatus.should_exit_event is a class-level
  anyio.Event lazily created on first SSE response. It binds to the
  asyncio event loop that is running at that moment. pytest-asyncio
  (>=0.21, function-scoped loop default in 1.x) creates a fresh event
  loop per async test, so the second SSE test inherits an Event bound
  to a now-closed loop and the SSE response raises:

    RuntimeError: <asyncio.locks.Event ...> is bound to a different event loop

  This made 5 streaming tests fail on main:
    - test_stream_concatenated_content_matches_engine_decode
    - test_stream_finish_reason_length_on_max_tokens
    - test_stream_returns_done_sentinel_at_end
    - test_stream_each_chunk_has_required_openai_fields
    - test_stream_completion_id_consistent_across_chunks

Fix:
  Add an autouse fixture in tests/inference_engine/server/conftest.py
  that resets AppStatus.should_exit_event to None before and after
  every test in this package. Production code is unaffected — uvicorn
  stays on a single loop for the lifetime of the process so the lazy
  init runs exactly once there.

Result:
  tests/inference_engine/server/test_app_streaming.py: 11 passed
  tests/inference_engine/server/  (full suite):       215 passed

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: FluffyAIcode <FluffyAIcode@users.noreply.github.com>

Author: FluffyAIcode

tests/inference_engine/server/conftest.py

@@ -30,6 +30,51 @@
 from inference_engine.server.engine import EngineResult
 
 
+# ---------------------------------------------------------------------------
+# sse-starlette compatibility shim
+#
+# ``sse_starlette.sse.EventSourceResponse`` lazily creates a class-level
+# ``anyio.Event`` (``AppStatus.should_exit_event``) the first time it is
+# instantiated. The Event is bound to whichever asyncio event loop is
+# running at that moment. pytest-asyncio (>=0.21, with the function-
+# scoped event-loop default in 1.x) creates a fresh event loop per
+# async test, so the *second* SSE-driven test inherits an Event bound
+# to a now-closed loop and the SSE response raises::
+#
+#     RuntimeError: <asyncio.locks.Event ...> is bound to a different event loop
+#
+# The fix is to reset the class-level cached Event before every test
+# that exercises the SSE app. Production code is unaffected — uvicorn
+# stays on a single loop for the lifetime of the process and the lazy
+# init runs exactly once there.
+#
+# We make this autouse at the package level so any future SSE test in
+# this directory picks the reset up automatically.
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture(autouse=True)
+def _reset_sse_starlette_app_status():
+    """Reset ``sse_starlette`` shutdown event between async tests.
+
+    Without this, only the first async streaming test in a session
+    succeeds; subsequent tests fail because the cached anyio.Event is
+    still bound to the previous, now-closed event loop.
+    """
+    try:
+        from sse_starlette.sse import AppStatus  # type: ignore
+    except ImportError:  # pragma: no cover - sse_starlette is a hard dep
+        yield
+        return
+    AppStatus.should_exit_event = None
+    AppStatus.should_exit = False
+    try:
+        yield
+    finally:
+        AppStatus.should_exit_event = None
+        AppStatus.should_exit = False
+
+
 class DeterministicTokenizer:
     """Tiny deterministic tokenizer that maps words to integer ids.