Upload app/agent/nodes.py with huggingface_hub

app/agent/nodes.py

@@ -1,132 +1,81 @@
-from typing import Dict, Any
+import json
+import logging
 from app.agent.state import AgentState
-from app.services.llm import get_llm_service
-from app.services.file_generator import get_file_generator
-from app.models.question import Question, Answer
+from app.agent.prompts import (
+    SYSTEM_PROMPT,
+    INITIAL_QUESTIONS_PROMPT,
+    analyze_round_prompt,
+    next_questions_prompt,
+    generate_checklist_prompt,
+    generate_markdown_prompt,
+)
+from app.models.question import QuestionOut
 from app.models.checklist import ChecklistItem
+from app.services.llm import gemini_service
 
+logger = logging.getLogger(__name__)
 
-def generate_initial_questions(state: AgentState) -> Dict[str, Any]:
-    """Генерирует первые 3 вопроса для начала интервью"""
-    llm = get_llm_service()
-    questions_data = llm.generate_initial_questions()
-    
-    questions = [
-        Question(id=q["id"], text=q["text"])
-        for q in questions_data
-    ]
-    
-    return {
-        "current_questions": questions,
-        "current_round": 1,
-        "waiting_for_answers": True
-    }
-
-
-def process_answers(state: AgentState) -> Dict[str, Any]:
-    """Обрабатывает полученные ответы и создает Answer объекты"""
-    transcripts = state.get("pending_transcripts", [])
-    current_questions = state.get("current_questions", [])
-    current_round = state.get("current_round", 1)
-    all_answers = list(state.get("all_answers", []))
-    
-    # Создаем Answer объекты из транскриптов
-    for i, transcript in enumerate(transcripts):
-        if i < len(current_questions):
-            answer = Answer(
-                question_id=current_questions[i].id,
-                question_text=current_questions[i].text,
-                audio_transcript=transcript,
-                round_number=current_round
-            )
-            all_answers.append(answer)
-    
-    return {
-        "all_answers": all_answers,
-        "pending_transcripts": [],
-        "waiting_for_answers": False
-    }
-
-
-def analyze_round(state: AgentState) -> Dict[str, Any]:
-    """Анализирует ответы раунда и генерирует следующие вопросы или завершает"""
-    llm = get_llm_service()
-    
-    current_round = state.get("current_round", 1)
-    all_answers = state.get("all_answers", [])
-    round_summaries = list(state.get("round_summaries", []))
-    
-    # Анализируем раунд
-    result = llm.analyze_round_and_generate_questions(
-        round_number=current_round,
-        all_answers=all_answers,
-        round_summaries=round_summaries
+
+async def generate_initial_questions(state: AgentState) -> dict:
+    logger.info(f"Generating initial questions for session {state['session_id']}")
+    result = await gemini_service.generate_json(SYSTEM_PROMPT, INITIAL_QUESTIONS_PROMPT)
+    questions = [QuestionOut(id=q["id"], text=q["text"]) for q in result]
+    return {"current_questions": questions, "current_round": 1}
+
+
+async def analyze_round(state: AgentState) -> dict:
+    round_num = state["current_round"]
+    logger.info(f"Analyzing round {round_num} for session {state['session_id']}")
+
+    # Build Q&A text for current round
+    round_answers = [a for a in state["all_answers"] if a.round_number == round_num]
+    qa_text = "\n".join(
+        f"В: {a.question_text}\nО: {a.audio_transcript}" for a in round_answers
+    )
+    prev_summaries = "\n---\n".join(state["round_summaries"])
+
+    result = await gemini_service.generate_json(
+        SYSTEM_PROMPT, analyze_round_prompt(round_num, qa_text, prev_summaries)
+    )
+    new_summaries = list(state["round_summaries"]) + [result["summary"]]
+    return {"round_summaries": new_summaries}
+
+
+async def generate_next_questions(state: AgentState) -> dict:
+    next_round = state["current_round"] + 1
+    logger.info(f"Generating questions for round {next_round}, session {state['session_id']}")
+
+    all_summaries = "\n---\n".join(state["round_summaries"])
+    result = await gemini_service.generate_json(
+        SYSTEM_PROMPT, next_questions_prompt(next_round, all_summaries)
+    )
+    questions = [QuestionOut(id=q["id"], text=q["text"]) for q in result]
+    return {"current_questions": questions, "current_round": next_round}
+
+
+async def generate_checklist(state: AgentState) -> dict:
+    logger.info(f"Generating checklist for session {state['session_id']}")
+
+    all_summaries = "\n---\n".join(state["round_summaries"])
+    all_qa = "\n\n".join(
+        f"Раунд {a.round_number} — В: {a.question_text}\nО: {a.audio_transcript}"
+        for a in state["all_answers"]
+    )
+    result = await gemini_service.generate_json(
+        SYSTEM_PROMPT, generate_checklist_prompt(all_summaries, all_qa)
+    )
+    items = [ChecklistItem(**item) for item in result]
+    return {"checklist_items": items, "is_complete": True}
+
+
+async def generate_markdown(state: AgentState) -> dict:
+    logger.info(f"Generating markdown for session {state['session_id']}")
+
+    checklist_json = json.dumps(
+        [item.model_dump() for item in state["checklist_items"]], ensure_ascii=False, indent=2
     )
-    
-    # Добавляем саммари раунда
-    round_summaries.append(result.get("round_summary", ""))
-    
-    # Если это не последний раунд - генерируем следующие вопросы
-    if current_round < state.get("max_rounds", 3):
-        questions_data = result.get("questions", [])
-        questions = [
-            Question(id=q["id"], text=q["text"])
-            for q in questions_data
-        ]
-        
-        return {
-            "current_questions": questions,
-            "current_round": current_round + 1,
-            "round_summaries": round_summaries,
-            "waiting_for_answers": True,
-            "is_complete": False
-        }
-    else:
-        # Последний раунд - готовимся к генерации чеклиста
-        return {
-            "round_summaries": round_summaries,
-            "waiting_for_answers": False,
-            "is_complete": False
-        }
-
-
-def generate_checklist(state: AgentState) -> Dict[str, Any]:
-    """Генерирует финальный чеклист"""
-    llm = get_llm_service()
-    file_gen = get_file_generator()
-    
-    all_answers = state.get("all_answers", [])
-    round_summaries = state.get("round_summaries", [])
-    session_id = state.get("session_id", "unknown")
-    
-    # Генерируем чеклист
-    result = llm.generate_checklist(all_answers, round_summaries)
-    
-    checklist_items = [
-        ChecklistItem(**item)
-        for item in result.get("checklist", [])
-    ]
-    
-    # Генерируем Markdown
-    markdown = file_gen.generate_markdown(
-        session_id=session_id,
-        checklist=checklist_items,
-        round_summaries=round_summaries
+    result = await gemini_service.generate(
+        SYSTEM_PROMPT,
+        generate_markdown_prompt(checklist_json, state["session_id"]),
     )
-    
-    return {
-        "checklist_items": checklist_items,
-        "markdown_content": markdown,
-        "is_complete": True
-    }
-
-
-def check_round_complete(state: AgentState) -> str:
-    """Проверяет, нужно ли продолжать или завершать"""
-    current_round = state.get("current_round", 1)
-    max_rounds = state.get("max_rounds", 3)
-    
-    if current_round >= max_rounds:
-        return "generate_checklist"
-    else:
-        return "wait_for_answers"
+    return {"markdown_content": result}