토큰 스트리밍 실제 구현 + 시스템 헬스 엔드포인트

- aiRouter: provider.stream()으로 실제 토큰 단위 SSE 스트리밍 (non-tool path)
- asyncio.Queue + 별도 스레드로 동기 Generator → async SSE 브리지
- tool 라운드 마지막 응답도 실제 스트리밍으로 전환
- /api/system/health: 세션 수, 대화 수, 엔진 상태, 메모리 사용량 반환
- Windows/Linux 양쪽 메모리 측정 (resource/psutil 폴백)
- testSystemHealth 테스트 추가 (총 251개)

Author: eddmpython

src/codaro/api/aiRouter.py

@@ -394,20 +394,44 @@ async def apiChatStream(request: Request):
         if sessionId:
             executor.setActiveSession(sessionId)
 
+        async def _yieldTokenStream(messages):
+            loop = asyncio.get_running_loop()
+            queue: asyncio.Queue[str | None] = asyncio.Queue()
+
+            def _runStream():
+                try:
+                    for token in llmProvider.stream(messages):
+                        loop.call_soon_threadsafe(queue.put_nowait, token)
+                finally:
+                    loop.call_soon_threadsafe(queue.put_nowait, None)
+
+            thread = threading.Thread(target=_runStream, daemon=True)
+            thread.start()
+
+            accumulated = ""
+            while True:
+                token = await queue.get()
+                if token is None:
+                    break
+                accumulated += token
+                yield f"data: {json.dumps({'type': 'token', 'content': accumulated}, ensure_ascii=False)}\n\n"
+
+            convManager.addAssistantMessage(conversationId, accumulated)
+            yield f"data: {json.dumps({'type': 'done', 'answer': accumulated, 'provider': llmProvider.config.provider, 'model': llmProvider.resolvedModel, 'usage': None, 'toolCalls': []}, ensure_ascii=False)}\n\n"
+            thread.join(timeout=2)
+
         async def _streamGenerate():
             nonlocal msgs, conversationId
             yield f"data: {json.dumps({'type': 'start', 'conversationId': conversationId}, ensure_ascii=False)}\n\n"
 
+            if not (llmProvider.supportsNativeTools and tools):
+                async for chunk in _yieldTokenStream(msgs):
+                    yield chunk
+                return
+
             maxToolRounds = 10
             for _round in range(maxToolRounds):
-                if llmProvider.supportsNativeTools and tools:
-                    response = llmProvider.completeWithTools(msgs, tools)
-                else:
-                    response = llmProvider.complete(msgs)
-                    convManager.addAssistantMessage(conversationId, response.answer)
-                    yield f"data: {json.dumps({'type': 'token', 'content': response.answer}, ensure_ascii=False)}\n\n"
-                    yield f"data: {json.dumps({'type': 'done', 'answer': response.answer, 'provider': response.provider, 'model': response.model, 'usage': response.usage, 'toolCalls': []}, ensure_ascii=False)}\n\n"
-                    return
+                response = llmProvider.completeWithTools(msgs, tools)
 
                 if not response.toolCalls:
                     convManager.addAssistantMessage(conversationId, response.answer)
@@ -435,10 +459,8 @@ async def _streamGenerate():
 
                 yield f"data: {json.dumps({'type': 'tool_results', 'toolCalls': toolResults}, ensure_ascii=False)}\n\n"
 
-            finalResponse = llmProvider.complete(msgs)
-            convManager.addAssistantMessage(conversationId, finalResponse.answer)
-            yield f"data: {json.dumps({'type': 'token', 'content': finalResponse.answer}, ensure_ascii=False)}\n\n"
-            yield f"data: {json.dumps({'type': 'done', 'answer': finalResponse.answer, 'provider': finalResponse.provider, 'model': finalResponse.model, 'usage': finalResponse.usage, 'toolCalls': []}, ensure_ascii=False)}\n\n"
+            async for chunk in _yieldTokenStream(msgs):
+                yield chunk
 
         return StreamingResponse(_streamGenerate(), media_type="text/event-stream")
 

src/codaro/api/systemRouter.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import os
+import sys
 from typing import Any
 
 from fastapi import APIRouter
@@ -137,4 +139,40 @@ async def apiUninstallPackage(request: PackageRequest) -> dict[str, Any]:
         )
         return result.model_dump()
 
+    @router.get("/api/system/health")
+    async def apiSystemHealth() -> dict[str, Any]:
+        processMemoryMb: float | None = None
+        try:
+            import resource as _resource
+            processMemoryMb = round(_resource.getrusage(_resource.RUSAGE_SELF).ru_maxrss / 1024, 1)
+        except (ImportError, AttributeError):
+            pass
+        if processMemoryMb is None:
+            try:
+                import psutil
+                processMemoryMb = round(psutil.Process(os.getpid()).memory_info().rss / (1024 * 1024), 1)
+            except (ImportError, AttributeError):
+                pass
+
+        from .aiRouter import _getConversationManager
+        convManager = _getConversationManager()
+
+        return {
+            "status": "ok",
+            "python": sys.version,
+            "pid": os.getpid(),
+            "processMemoryMb": processMemoryMb,
+            "sessions": {
+                "active": state.sessionManager.sessionCount,
+            },
+            "conversations": {
+                "active": convManager.conversationCount,
+            },
+            "engine": {
+                "status": workspaceEngine.status,
+                "executionCount": workspaceEngine.executionCount,
+                "variableCount": len(workspaceEngine.getVariables()),
+            },
+        }
+
     return router

tests/testServerApi.py

@@ -226,6 +226,22 @@ def testEnvironmentInfo() -> None:
     assert "platform" in info
 
 
+def testSystemHealth() -> None:
+    client = TestClient(createServerApp())
+
+    response = client.get("/api/system/health")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "ok"
+    assert "python" in data
+    assert "pid" in data
+    assert "sessions" in data
+    assert "conversations" in data
+    assert "engine" in data
+    assert data["sessions"]["active"] >= 0
+    assert data["conversations"]["active"] >= 0
+
+
 def testStructuredErrorEnvelope() -> None:
     client = TestClient(createServerApp())