Update app.py

app.py

@@ -540,7 +540,7 @@ Present the revised final plan including:
 Create a final masterplan that all 16 writers can clearly understand."""
     
     def create_writer_prompt(self, writer_number: int, director_plan: str, previous_content: str, language: str = "English") -> str:
-        """Individual writer prompt - 3페이지, 1500-1800단어"""
+        """Individual writer prompt - 강화된 길이 요구사항"""
         pages_start = (writer_number - 1) * 3 + 1
         pages_end = writer_number * 3
         
@@ -553,24 +553,32 @@ Create a final masterplan that all 16 writers can clearly understand."""
 {'이전까지의 내용:' if previous_content else '당신이 첫 번째 작성자입니다.'}
 {previous_content[-2000:] if previous_content else ''}
 
-다음 지침에 따라 작성하세요:
+**중요 지침:**
 
-1. **분량**: 정확히 3페이지 (페이지당 약 500-600단어, 총 1500-1800단어)
-2. **연속성**: 이전 내용과 자연스럽게 이어지도록
-3. **일관성**: 
-   - 등장인물의 성격과 말투 유지
+1. **필수 분량**: 
+   - 최소 1500단어, 최대 1800단어
+   - 대략 7500-9000자 (공백 포함)
+   - 3페이지 분량을 반드시 채워야 합니다
+
+2. **분량 확보 전략**:
+   - 상세한 장면 묘사 포함
+   - 인물의 내면 심리 깊이 있게 탐구
+   - 대화와 행동을 구체적으로 표현
+   - 배경과 분위기를 생생하게 그려내기
+   - 감각적 세부사항(시각, 청각, 촉각 등) 활용
+
+3. **연속성과 일관성**:
+   - 이전 내용과 자연스럽게 연결
+   - 인물 성격과 말투 유지
    - 시간선과 공간 설정 준수
-   - 이미 제시된 사실들과 모순 없이
-4. **발전**: 
-   - 플롯을 전진시키기
-   - 인물의 성장이나 변화 표현
-   - 긴장감 조절
-5. **문체**: 
-   - 전체적인 톤과 분위기 유지
-   - 독자의 몰입을 해치지 않기
-
-중요: 페이지 구분 표시를 절대 하지 마세요. 자연스럽게 이어지는 서사로 작성하세요.
-반드시 1500-1800단어 분량을 채워주세요."""
+
+4. **서사 발전**:
+   - 플롯을 의미 있게 전진시키기
+   - 긴장감 적절히 조절
+   - 독자의 관심 유지
+
+**작성 시작:**
+이제 1500-1800단어 분량의 소설을 작성하세요. 페이지 구분 표시는 하지 마세요."""
         else:
             return f"""You are Writer #{writer_number}. Write pages {pages_start}-{pages_end} (3 pages) of the 48-page novella.
 
@@ -580,24 +588,32 @@ Director's Masterplan:
 {'Previous content:' if previous_content else 'You are the first writer.'}
 {previous_content[-2000:] if previous_content else ''}
 
-Write according to these guidelines:
+**CRITICAL INSTRUCTIONS:**
 
-1. **Length**: Exactly 3 pages (about 500-600 words per page, total 1500-1800 words)
-2. **Continuity**: Flow naturally from previous content
-3. **Consistency**: 
+1. **MANDATORY LENGTH**: 
+   - Minimum 1500 words, Maximum 1800 words
+   - Approximately 7500-9000 characters
+   - You MUST fill 3 full pages
+
+2. **LENGTH STRATEGIES**:
+   - Include detailed scene descriptions
+   - Explore character's inner psychology deeply
+   - Express dialogue and actions concretely
+   - Paint backgrounds and atmosphere vividly
+   - Use sensory details (visual, auditory, tactile, etc.)
+
+3. **CONTINUITY & CONSISTENCY**:
+   - Flow naturally from previous content
    - Maintain character personalities and speech
    - Follow timeline and spatial settings
-   - No contradictions with established facts
-4. **Development**: 
-   - Advance the plot
-   - Show character growth or change
-   - Control tension
-5. **Style**: 
-   - Maintain overall tone and atmosphere
-   - Keep reader immersion
-
-Important: DO NOT use any page markers. Write as continuous narrative.
-You MUST write 1500-1800 words."""
+
+4. **NARRATIVE DEVELOPMENT**:
+   - Advance the plot meaningfully
+   - Control tension appropriately
+   - Maintain reader interest
+
+**BEGIN WRITING:**
+Now write your 1500-1800 word section. Do not use any page markers."""
     
     def create_critic_writer_prompt(self, writer_number: int, writer_content: str, director_plan: str, all_previous_content: str, language: str = "English") -> str:
         """Critic's review of individual writer's work"""
@@ -942,7 +958,7 @@ Present a complete 48-page novel integrating all writers' contributions."""
             time.sleep(0.02)
     
     def call_llm_streaming(self, messages: List[Dict[str, str]], role: str, language: str = "English") -> Generator[str, None, None]:
-        """Streaming LLM API call with adjusted token limits"""
+        """Streaming LLM API call with improved prompting"""
         
         if self.test_mode:
             logger.info(f"Test mode streaming - Role: {role}, Language: {language}")
@@ -954,37 +970,50 @@ Present a complete 48-page novel integrating all writers' contributions."""
         try:
             system_prompts = self.get_system_prompts(language)
             
+            # 작가에게 더 강한 시스템 프롬프트 추가
+            if role.startswith("writer"):
+                if language == "Korean":
+                    system_prompts[role] += "\n\n**절대적 요구사항**: 당신은 반드시 1500-1800단어를 작성해야 합니다. 이것은 협상 불가능한 요구사항입니다. 짧은 응답은 허용되지 않습니다."
+                else:
+                    system_prompts[role] += "\n\n**ABSOLUTE REQUIREMENT**: You MUST write 1500-1800 words. This is non-negotiable. Short responses are not acceptable."
+            
             full_messages = [
                 {"role": "system", "content": system_prompts.get(role, "")},
                 *messages
             ]
             
-            # 작성자들에게는 적절한 토큰 할당 (3페이지 = 1500-1800단어 = 약 7500-9000토큰)
+            # 작성자들에게는 더 많은 토큰 할당
             if role.startswith("writer"):
-                max_tokens = 10240  # 충분한 여유
-            elif role == "director" and "최종" in str(messages) or "final" in str(messages):
-                max_tokens = 32768  # 최종 감독은 모든 내용을 통합
+                max_tokens = 12000  # 증가
+                temperature = 0.8   # 약간 증가
+                top_p = 0.95       # 약간 증가
+            elif role == "director" and ("최종" in str(messages) or "final" in str(messages)):
+                max_tokens = 40000  # 증가
+                temperature = 0.6
+                top_p = 0.9
             else:
-                max_tokens = 8192
+                max_tokens = 10000
+                temperature = 0.6
+                top_p = 0.9
             
             payload = {
                 "model": self.model_id,
                 "messages": full_messages,
                 "max_tokens": max_tokens,
-                "temperature": 0.7 if role.startswith("writer") else 0.6,
-                "top_p": 0.9,
+                "temperature": temperature,
+                "top_p": top_p,
                 "stream": True,
                 "stream_options": {"include_usage": True}
             }
             
-            logger.info(f"API streaming call started - Role: {role}, Max tokens: {max_tokens}")
+            logger.info(f"API streaming call started - Role: {role}, Max tokens: {max_tokens}, Temperature: {temperature}")
             
             response = requests.post(
                 self.api_url,
                 headers=self.create_headers(),
                 json=payload,
                 stream=True,
-                timeout=30
+                timeout=60  # 타임아웃 증가
             )
             
             if response.status_code != 200:
@@ -1003,7 +1032,7 @@ Present a complete 48-page novel integrating all writers' contributions."""
                         if data == "[DONE]":
                             if buffer:
                                 yield buffer
-                            logger.info(f"Streaming complete for {role}: {len(total_content)} chars")
+                            logger.info(f"Streaming complete for {role}: {len(total_content)} chars, {len(total_content.split())} words")
                             break
                         try:
                             chunk = json.loads(data)
@@ -1014,7 +1043,7 @@ Present a complete 48-page novel integrating all writers' contributions."""
                                     total_content += content
                                     
                                     # 작가는 더 큰 버퍼 사용
-                                    buffer_size = 300 if role.startswith("writer") else 150
+                                    buffer_size = 500 if role.startswith("writer") else 200
                                     
                                     if len(buffer) > buffer_size or '\n\n' in buffer:
                                         yield buffer
@@ -1025,11 +1054,61 @@ Present a complete 48-page novel integrating all writers' contributions."""
             if buffer:
                 yield buffer
             
-            # 작가의 경우 내용 길이 확인
+            # 작가의 경우 내용 길이 확인 및 재시도
             if role.startswith("writer"):
                 word_count = len(total_content.split())
                 if word_count < 1400:
-                    logger.warning(f"Writer {role} produced only {word_count} words!")
+                    logger.warning(f"Writer {role} produced only {word_count} words! Requesting continuation...")
+                    
+                    # 추가 요청
+                    continuation_prompt = f"Continue writing to reach the required 1500-1800 words. You have written {word_count} words so far. Write {1500 - word_count} more words to complete your section."
+                    
+                    if language == "Korean":
+                        continuation_prompt = f"필수 분량 1500-1800단어를 채우기 위해 계속 작성하세요. 지금까지 {word_count}단어를 작성했습니다. {1500 - word_count}단어를 더 작성하여 섹션을 ��성하세요."
+                    
+                    full_messages.append({"role": "assistant", "content": total_content})
+                    full_messages.append({"role": "user", "content": continuation_prompt})
+                    
+                    # 추가 생성 요청
+                    continuation_payload = {
+                        "model": self.model_id,
+                        "messages": full_messages,
+                        "max_tokens": 6000,
+                        "temperature": temperature,
+                        "top_p": top_p,
+                        "stream": True
+                    }
+                    
+                    logger.info(f"Requesting continuation for {role}...")
+                    
+                    continuation_response = requests.post(
+                        self.api_url,
+                        headers=self.create_headers(),
+                        json=continuation_payload,
+                        stream=True,
+                        timeout=60
+                    )
+                    
+                    if continuation_response.status_code == 200:
+                        for line in continuation_response.iter_lines():
+                            if line:
+                                line = line.decode('utf-8')
+                                if line.startswith("data: "):
+                                    data = line[6:]
+                                    if data == "[DONE]":
+                                        break
+                                    try:
+                                        chunk = json.loads(data)
+                                        if "choices" in chunk and chunk["choices"]:
+                                            content = chunk["choices"][0].get("delta", {}).get("content", "")
+                                            if content:
+                                                yield content
+                                                total_content += content
+                                    except json.JSONDecodeError:
+                                        continue
+                        
+                        final_word_count = len(total_content.split())
+                        logger.info(f"Final word count for {role}: {final_word_count}")
                             
         except requests.exceptions.Timeout:
             yield "⏱️ API call timed out. Please try again."
@@ -1040,7 +1119,7 @@ Present a complete 48-page novel integrating all writers' contributions."""
             yield f"❌ Error occurred: {str(e)}"
     
     def get_system_prompts(self, language: str) -> Dict[str, str]:
-        """Get system prompts for all 16 writers"""
+        """Get system prompts for all 16 writers with enhanced length requirements"""
         if language == "Korean":
             prompts = {
                 "director": "당신은 48페이지 중편 소설을 기획하고 감독하는 문학 감독자입니다. 체계적이고 창의적인 스토리 구조를 만들어냅니다.",
@@ -1068,7 +1147,7 @@ Present a complete 48-page novel integrating all writers' contributions."""
             ]
             
             for i, role_desc in enumerate(writer_roles, 1):
-                prompts[f"writer{i}"] = f"당신은 {role_desc} 반드시 1500-1800단어를 작성하세요."
+                prompts[f"writer{i}"] = f"당신은 {role_desc} 반드시 1500-1800단어를 작성하세요. 이는 절대적인 요구사항입니다."
                 
             return prompts
         else:
@@ -1098,7 +1177,7 @@ Present a complete 48-page novel integrating all writers' contributions."""
             ]
             
             for i, role_desc in enumerate(writer_roles, 1):
-                prompts[f"writer{i}"] = f"You are {role_desc} You MUST write 1500-1800 words."
+                prompts[f"writer{i}"] = f"You are {role_desc} You MUST write 1500-1800 words. This is an absolute requirement."
                 
             return prompts
     
@@ -1859,8 +1938,39 @@ def create_interface():
     
     return interface
 
+# 빠른 테스트를 위한 축소 버전 추가
+def create_quick_test_interface():
+    """빠른 테스트를 위한 간단한 인터페이스"""
+    with gr.Blocks(title="Novel Writing System - Quick Test") as interface:
+        gr.Markdown("# 🚀 Quick Test Mode - 3 Writers Only")
+        
+        with gr.Row():
+            query_input = gr.Textbox(label="Novel Theme", placeholder="Enter theme...")
+            language = gr.Radio(["English", "Korean"], value="English", label="Language")
+            submit_btn = gr.Button("Start Quick Test")
+        
+        output = gr.Textbox(label="Output", lines=20)
+        
+        def quick_test(query, lang):
+            system = NovelWritingSystem()
+            # 3명의 작가만 테스트
+            stages = ["Director Plan", "Writer 1", "Writer 2", "Writer 3", "Final"]
+            result = f"Testing with theme: {query}\n\n"
+            
+            for stage in stages:
+                result += f"Processing {stage}...\n"
+                time.sleep(1)  # 시뮬레이션
+                
+            return result + "\nQuick test complete!"
+        
+        submit_btn.click(quick_test, inputs=[query_input, language], outputs=output)
+    
+    return interface
+
 # Main execution
 if __name__ == "__main__":
+    import sys
+    
     logger.info("Starting SOMA Novel Writing System...")
     
     # Check environment
@@ -1874,7 +1984,13 @@ if __name__ == "__main__":
     NovelDatabase.init_db()
     logger.info("Database initialized successfully.")
     
-    interface = create_interface()
+    # 빠른 테스트 모드 옵션
+    if "--quick-test" in sys.argv:
+        logger.info("Running in QUICK TEST mode")
+        interface = create_quick_test_interface()
+    else:
+        logger.info("Running in FULL mode")
+        interface = create_interface()
     
     interface.launch(
         server_name="0.0.0.0",