Update app.py

app.py

@@ -563,10 +563,11 @@ class NovelWritingSystem:
         return full_content
 
     def call_llm_streaming(self, messages: List[Dict[str, str]], role: str, language: str) -> Generator[str, None, None]:
-        """LLM 스트리밍 호출 (안전한 에러 처리)"""
+        """LLM 스트리밍 호출 (완전한 에러 처리 및 디버깅)"""
         try:
             system_prompts = self.get_system_prompts(language)
             full_messages = [{"role": "system", "content": system_prompts.get(role, "You are a helpful assistant.")}, *messages]
+            
             payload = {
                 "model": self.model_id,
                 "messages": full_messages,
@@ -579,80 +580,114 @@ class NovelWritingSystem:
                 "stream_options": {"include_usage": True}
             }
             
-            logger.info(f"API 호출 시작 - 역할: {role}")
-            response = requests.post(self.api_url, headers=self.create_headers(), json=payload, stream=True, timeout=180)
-            response.raise_for_status()
+            logger.info(f"[{role}] API 스트리밍 시작")
+            
+            # API 호출
+            response = requests.post(
+                self.api_url, 
+                headers=self.create_headers(), 
+                json=payload, 
+                stream=True, 
+                timeout=180
+            )
             
+            # 상태 코드 확인
+            if response.status_code != 200:
+                logger.error(f"API 응답 오류: {response.status_code}")
+                logger.error(f"응답 내용: {response.text[:500]}")
+                yield f"❌ API 오류 (상태 코드: {response.status_code})"
+                return
+            
+            response.raise_for_status()
+        
+        # 스트리밍 처리
             buffer = ""
+            total_content = ""
             chunk_count = 0
-            
+            error_count = 0
+        
             for line in response.iter_lines():
-                if line:
-                    line_str = line.decode('utf-8')
-                    if line_str.startswith("data: "):
-                        data = line_str[6:]
-                        if data == "[DONE]": 
-                            logger.info(f"스트리밍 완료 - 총 {chunk_count}개 청크 처리")
-                            break
+                if not line:
+                    continue
+                
+                try:
+                    line_str = line.decode('utf-8').strip()
+                
+                # SSE 형식 확인
+                    if not line_str.startswith("data: "):
+                        continue
+                    
+                    data_str = line_str[6:]  # "data: " 제거
+                
+                # 스트림 종료 확인
+                    if data_str == "[DONE]":
+                        logger.info(f"[{role}] 스트리밍 완료 - 총 {len(total_content)} 문자")
+                        break
+                
+                # JSON 파싱
+                    try:
+                        data = json.loads(data_str)
+                    except json.JSONDecodeError:
+                        logger.warning(f"JSON 파싱 실패: {data_str[:100]}")
+                        continue
+                
+                # choices 배열 안전하게 확인
+                    choices = data.get("choices", None)
+                    if not choices or not isinstance(choices, list) or len(choices) == 0:
+                        # 에러 응답 확인
+                        if "error" in data:
+                            error_msg = data.get("error", {}).get("message", "Unknown error")
+                            logger.error(f"API 에러: {error_msg}")
+                            yield f"❌ API 에러: {error_msg}"
+                            return
+                        continue
+                    
+                    # delta에서 content 추출
+                    delta = choices[0].get("delta", {})
+                    content = delta.get("content", "")
+                    
+                    if content:
+                        buffer += content
+                        total_content += content
+                        chunk_count += 1
                         
-                        try:
-                            chunk = json.loads(data)
-                            
-                            # 디버깅을 위해 첫 몇 개 청크 로깅
-                            if chunk_count < 3:
-                                logger.debug(f"청크 {chunk_count}: {json.dumps(chunk, ensure_ascii=False)[:200]}")
-                            
-                            # 안전한 content 추출
-                            choices = chunk.get("choices", [])
-                            if choices and len(choices) > 0:
-                                delta = choices[0].get("delta", {})
-                                content = delta.get("content", "")
-                                
-                                if content:
-                                    buffer += content
-                                    chunk_count += 1
-                                    
-                                    # 버퍼가 충분히 차거나 줄바꿈이 있을 때 yield
-                                    if len(buffer) > 100 or "\n" in buffer:
-                                        yield buffer
-                                        buffer = ""
-                            
-                            # 에러 메시지 체크
-                            elif chunk.get("error"):
-                                error_msg = chunk.get("error", {}).get("message", "Unknown error")
-                                logger.error(f"API 에러 응답: {error_msg}")
-                                yield f"❌ API 오류: {error_msg}"
-                                return
-                                
-                        except json.JSONDecodeError as e:
-                            logger.warning(f"JSON 파싱 오류: {e}, 데이터: {data[:100]}")
-                            continue
-                        except Exception as e:
-                            logger.error(f"청크 처리 중 예외: {e}")
-                            continue
+                        # 100자 또는 줄바꿈마다 yield
+                        if len(buffer) >= 100 or '\n' in buffer:
+                            yield buffer
+                            buffer = ""
+                            time.sleep(0.01)  # UI 업데이트를 위한 짧은 대기
+                    
+                except Exception as e:
+                    error_count += 1
+                    logger.error(f"청크 처리 오류 #{error_count}: {str(e)}")
+                    if error_count > 10:  # 너무 많은 에러시 중단
+                        yield f"❌ 스트리밍 중 과도한 오류 발생"
+                        return
+                    continue
             
-            # 남은 버퍼 내용 출력
-            if buffer: 
+            # 남은 버퍼 처리
+            if buffer:
                 yield buffer
-                
-            # 청크가 하나도 처리되지 않았다면
+            
+        # 결과 확인
             if chunk_count == 0:
-                logger.error("응답에서 콘텐츠를 찾을 수 없습니다.")
-                yield "❌ API 응답에 콘텐츠가 없습니다."
+                logger.error(f"[{role}] 콘텐츠가 전혀 수신되지 않음")
+                yield "❌ API로부터 응답을 받지 못했습니다."
+            else:
+                logger.info(f"[{role}] 성공적으로 {chunk_count}개 청크, 총 {len(total_content)}자 수신")
                 
-        except requests.exceptions.HTTPError as e:
-            logger.error(f"HTTP 오류: {e}")
-            logger.error(f"응답 상태 코드: {e.response.status_code if e.response else 'N/A'}")
-            logger.error(f"응답 내용: {e.response.text[:500] if e.response else 'N/A'}")
-            yield f"❌ HTTP 오류: {e}"
-        except requests.exceptions.RequestException as e:
-            logger.error(f"API 요청 오류: {e}")
-            yield f"❌ API 오류: {e}"
+        except requests.exceptions.Timeout:
+            logger.error("API 요청 시간 초과")
+            yield "❌ API 요청 시간이 초과되었습니다."
+        except requests.exceptions.ConnectionError:
+            logger.error("API 연결 실패")
+            yield "❌ API 서버에 연결할 수 없습니다."
         except Exception as e:
-            logger.error(f"예기치 않은 오류: {e}", exc_info=True)
-            yield f"❌ 처리 오류: {e}"
-    
-    
+            logger.error(f"예기치 않은 오류: {type(e).__name__}: {str(e)}", exc_info=True)
+            yield f"❌ 오류 발생: {str(e)}"
+
+
+
 
 
     def get_system_prompts(self, language: str) -> Dict[str, str]: