Reworked system of routing should_continue, also logging for better managing and testing

src/config.py

@@ -3,6 +3,8 @@ from tools.tools import *
 from tools.code_interpreter import safe_code_run
 from langgraph.prebuilt import ToolNode
 from schemas import PlannerPlan
+from utils.utils import log_stage
+from langchain_core.messages import HumanMessage, SystemMessage, AIMessage, ToolMessage
 
 config = {"configurable": {"thread_id": "1"}, "recursion_limit" : 50}
 
@@ -15,12 +17,71 @@ TOOLS = [download_file_from_url, web_search,
 class DebuggingToolNode(ToolNode):
     def __init__(self, tools):
         super().__init__(tools)
-    
+
     def __call__(self, state):
-        print("=== TOOL EXECUTION STARTED ===")
-        result = super().__call__(state)
-        print("=== TOOL EXECUTION COMPLETED ===")
-        return result
+        log_stage("TOOL NODE", subtitle="Dispatching tool calls", icon="🛠️")
+        
+        messages = state.get("messages", [])
+        last_message = messages[-1] if messages else None
+        
+        if not last_message or not hasattr(last_message, "tool_calls"):
+            log_stage("TOOL ERROR", subtitle="No tool calls found", icon="❌")
+            return state
+            
+        tool_calls = last_message.tool_calls
+        log_stage("TOOL DISPATCH", subtitle=f"Executing {len(tool_calls)} tool(s)", icon="🔧")
+        for call in tool_calls:
+            print(f"   - {call['name']}: {call['args']}")
+        
+        try:
+            # Выполняем инструменты
+            result = super().__call__(state)
+            
+            # Проверяем результаты
+            new_messages = result.get("messages", [])
+            tool_messages = [msg for msg in new_messages[len(messages):] 
+                           if isinstance(msg, ToolMessage)]
+            
+            log_stage("TOOL RESULTS", subtitle=f"Got {len(tool_messages)} responses", icon="📨")
+            
+            # Логируем результаты
+            for msg in tool_messages:
+                content_preview = msg.content[:100] + "..." if len(msg.content) > 100 else msg.content
+                print(f"   - {msg.name}: {content_preview}")
+            
+            # Автоматически добавляем сигнал завершения шага после успешного выполнения инструментов
+            if tool_messages:
+                current_step = state.get("current_step", 0)
+                plan = state.get("plan")
+                
+                if plan and current_step < len(plan.steps):
+                    step_completion_msg = AIMessage(
+                        content=f"STEP COMPLETE: Successfully executed {len(tool_messages)} tool(s) for step {plan.steps[current_step].id}"
+                    )
+                    result["messages"] = result["messages"] + [step_completion_msg]
+                    log_stage("STEP COMPLETION", subtitle=f"Step {current_step + 1} marked complete", icon="✅")
+                    
+                    # Продвигаем к следующему шагу
+                    result["current_step"] = current_step + 1
+                    result["reasoning_done"] = False  # Сброс для следующего шага
+            
+            return result
+            
+        except Exception as exc:
+            log_stage("TOOL ERROR", subtitle=f"{type(exc).__name__}: {exc}", icon="❌")
+            print(f"Full error: {repr(exc)}")
+            
+            # Создаем ToolMessage для каждого failed tool call
+            error_messages = []
+            for call in tool_calls:
+                error_msg = ToolMessage(
+                    content=f"ERROR: {type(exc).__name__}: {exc}",
+                    tool_call_id=call.get("id") or "unknown_call",
+                    name=call.get("name", "unknown_tool"),
+                )
+                error_messages.append(error_msg)
+
+            return {"messages": messages + error_messages}
 
 
 TOOL_NODE = ToolNode(TOOLS)

src/nodes.py

@@ -1,9 +1,9 @@
 import os
-from typing import Optional
-
 from state import AgentState
 from tools.tools import preprocess_files
+from typing import Optional
 from langgraph.prebuilt import ToolNode
+
 from langchain_core.messages import HumanMessage, SystemMessage, AIMessage, ToolMessage
 
 from prompts.prompts import (
@@ -12,8 +12,10 @@ from prompts.prompts import (
     COMPLEXITY_ASSESSOR_PROMPT,
     CRITIC_PROMPT,
 )
+
 from config import llm, TOOLS, planner_llm, llm_with_tools
 from schemas import PlannerPlan, ComplexityLevel, CritiqueFeedback, ExecutionReport, ToolExecution
+
 from utils.utils import (
     format_final_answer,
     clean_message_history,
@@ -23,7 +25,6 @@ from utils.utils import (
     format_plan_overview,
 )
 
-
 def _build_planner_prompt(state: AgentState, extra_context: Optional[str] = None) -> str:
     tool_catalogue = ", ".join(sorted(tool.name for tool in TOOLS))
     file_paths = state.get("files", [])
@@ -35,15 +36,18 @@ def _build_planner_prompt(state: AgentState, extra_context: Optional[str] = None
         extra_context=extra,
     ).strip()
 
-def query_input(state: AgentState) -> AgentState:
+def query_input(state : AgentState) -> AgentState:
     log_stage("USER QUERY", icon="💡")
+    #print("=== USER QUERY TRANSFERED TO AGENT ===")
 
     files = state.get("files", [])
     if files:
+        print(f"Processing {len(files)} files:")
         log_stage("FILE PREPARATION", subtitle=f"Processing {len(files)} file(s)", icon="📁")
         file_info = preprocess_files(files)
-
+    
         for file_path, info in file_info.items():
+            print(f"  - {file_path}: {info['type']} ({info['size']} bytes) -> {info['suggested_tool']}")
             log_key_values(
                 [
                     ("path", file_path),
@@ -52,39 +56,42 @@ def query_input(state: AgentState) -> AgentState:
                     ("suggested_tool", info["suggested_tool"]),
                 ]
             )
-
         state["file_contents"] = file_info
         file_context = "\n\n=== AVAILABLE FILES FOR ANALYSIS ===\n"
         for file_path, info in file_info.items():
             filename = os.path.basename(file_path)
             file_context += f"File: {filename}\n"
-            file_context += f"  - Type: {info['type']}\n"
+            file_context += f"  - Type: {info['type']}\n"  
             file_context += f"  - Size: {info['size']} bytes\n"
             file_context += f"  - Suggested tool: {info['suggested_tool']}\n"
             if info.get("preview"):
                 file_context += f"  - Preview: {info['preview']}\n"
             file_context += "\n"
-
+        
+        # Добавляем инструкции по работе с файлами
         file_context += "IMPORTANT: Use the suggested tools to analyze these files before processing their data.\n"
         file_context += "File paths are available in the agent state and can be passed directly to analysis tools.\n"
-
-        original_query = state.get("query", "")
-        state["query"] = original_query + file_context
+    
     else:
         log_key_values([("files", "none provided")])
+        file_context = ""
+        original_query = state.get("query", "")
+        state["query"] = original_query + file_context
     return state
 
 
-def planner(state: AgentState) -> AgentState:
+def planner(state : AgentState) -> AgentState:
+
     log_stage("PLANNING", icon="🧭")
     planner_prompt = _build_planner_prompt(state)
 
     sys_stack = [
-        SystemMessage(content=planner_prompt),
-        HumanMessage(content=state["query"]),
-    ]
+            SystemMessage(content=planner_prompt),
+            HumanMessage(content=state["query"]),
+        ]
     plan: PlannerPlan = planner_llm.invoke(sys_stack)
-
+    
+    #print("=== GENERATED PLAN ===")
     display_plan(plan)
     return {
         "messages": state["messages"] + sys_stack,
@@ -95,19 +102,40 @@ def planner(state: AgentState) -> AgentState:
 
 
 def agent(state: AgentState) -> AgentState:
+    
+    """
+    sys_msg = SystemMessage(
+        content=SYSTEM_EXECUTOR_PROMPT.strip().format(
+            plan=json.dumps(state["plan"], indent=2)
+        )
+    )
+    """
     current_step = state.get("current_step", 0)
     reasoning_done = state.get("reasoning_done", False)
     plan: Optional[PlannerPlan] = state.get("plan")
+    #steps = state["plan"].steps
 
-    if not plan or not hasattr(plan, "steps"):
+    """
+    print(f"=== AGENT DEBUG ===")
+    print(f"Current step: {current_step}")
+    print(f"Reasoning done: {reasoning_done}")
+    print(f"Plan exists: {plan is not None}")
+    print(f"Total steps in plan: {len(plan.steps) if plan else 'No plan'}")
+
+    if not plan or not hasattr(plan, 'steps') or not plan.steps:
+        print("ERROR: No valid plan found!")
+    """
+
+    if not plan or not hasattr(plan, 'steps'):
         log_stage("PLAN VALIDATION", subtitle="Planner returned no actionable steps", icon="⚠️")
         warning = AIMessage(content="No valid plan available. <FINAL_ANSWER>")
         return {
             "messages": state["messages"] + [warning],
             "reasoning_done": False,
         }
-
+    
     steps = plan.steps
+    
     total_steps = len(steps)
 
     if total_steps == 0:
@@ -127,6 +155,8 @@ def agent(state: AgentState) -> AgentState:
         }
 
     current_step_info = steps[current_step]
+    #print(f"Executing step {current_step + 1}: {current_step_info.description}")
+
     log_stage(
         "EXECUTION",
         subtitle=f"Step {current_step + 1}/{total_steps}: {current_step_info.goal}",
@@ -157,7 +187,9 @@ def agent(state: AgentState) -> AgentState:
         ).strip()
     )
 
+
     if not reasoning_done:
+
         instruction = HumanMessage(
             content=(
                 "Provide reasoning for this step inside <REASONING>...</REASONING>. "
@@ -169,65 +201,67 @@ def agent(state: AgentState) -> AgentState:
         log_stage("REASONING", subtitle=f"{current_step_info.id}", icon="🧠")
         print(reasoning_response.content)
 
-        return {
-            "messages": state["messages"] + [reasoning_response],
-            "reasoning_done": True,
-        }
-
-    available_tools = {tool.name for tool in TOOLS}
-    if current_step_info.tool and current_step_info.tool not in available_tools:
-        log_stage(
-            "TOOL WARNING",
-            subtitle=f"Unknown tool '{current_step_info.tool}' in plan",
-            icon="⚠️",
-        )
-        warning = AIMessage(
-            content=(
-                f"<REASONING>Unable to execute {current_step_info.id}: tool "
-                f"'{current_step_info.tool}' is unavailable. Requesting replanning.</REASONING>"
-            )
-        )
-        print(warning.content)
-        return {
-            "messages": state["messages"] + [warning],
-            "reasoning_done": False,
-        }
-
-    execution_instruction = HumanMessage(
-        content=(
-            "Execute the planned action now. If a tool is required, call it with the "
-            "correct arguments. After success, respond with STEP COMPLETE. If inputs are "
-            "missing, explain the issue in <REASONING> without new tool calls."
-        )
-    )
-    stack = [system_message] + state["messages"] + [execution_instruction]
-    execution_response = llm_with_tools.invoke(stack)
+        # ✅ ДОБАВЛЕНО: Специальный контекст для файлов
+        file_context = ""
+        file_contents = state.get("file_contents", {})
+        if file_contents:
+            file_context = "\n\nAVAILABLE FILES IN CURRENT SESSION:\n"
+            for filepath, info in file_contents.items():
+                filename = os.path.basename(filepath)
+                file_context += f"- {filename}: {info['type']} file, suggested tool: {info['suggested_tool']}\n"
+                file_context += f"  Path: {filepath}\n"
+
+        reasoning_prompt = f"""
+        {SYSTEM_EXECUTOR_PROMPT}
+        
+        CURRENT TASK: You must perform reasoning for step {current_step + 1}.
+        
+        STEP INFO: {current_step_info}\n\n
 
-    if execution_response.tool_calls:
-        tool_names = ", ".join(call["name"] for call in execution_response.tool_calls)
-        log_stage("TOOL CALL", subtitle=f"{current_step_info.id} → {tool_names}", icon="🛠️")
-        print(execution_response.tool_calls)
-    else:
-        log_stage("EXECUTION OUTPUT", subtitle=current_step_info.id, icon="🛠️")
-        if execution_response.content:
-            print(execution_response.content)
+        FILE CONTEXT: {file_contents}
+        
+        CRITICAL: You MUST output your reasoning in <REASONING> tags, but DO NOT call any tools yet.
+        Explain what you need to do and why, then end your response.
 
-    advance = False
-    if execution_response.tool_calls:
-        advance = True
-    elif execution_response.content and (
-        "STEP COMPLETE" in execution_response.content or "<FINAL_ANSWER>" in execution_response.content
-    ):
-        advance = True
+        REASONING IS IMPERATIVE BEFORE ANY TOOL CALLS.
+        """
 
-    next_step = current_step + 1 if advance and current_step < total_steps else current_step
+        sys_msg = SystemMessage(content = reasoning_prompt)
+        stack = [sys_msg] + state["messages"]
 
-    return {
-        "messages": state["messages"] + [execution_response],
-        "current_step": next_step,
-        "reasoning_done": False,
-    }
+        step = llm.invoke(stack)
+        print("=== REASONING STEP ===")
+        print(step.content)
 
+        return {
+            "messages" : state["messages"] + [step],
+            "reasoning_done" : True
+        }
+    
+    else:
+        tool_prompt = f"""
+        Now execute the tool for step {current_step + 1}.
+        
+        You have already done the reasoning. Now call the appropriate tool with the correct parameters.
+        Available file paths: {list(state.get("file_contents", {}).keys())}\n
+        IMPORTANT NOTE: IF YOU DECIDED TO USE safe_code_run, MAKE SURE TO FINISH CALCULATIONS WITH print() or saving to a variable NAMED 'result' so that the output can be captured!
+        AVAILABLE TOOLS: {', '.join([tool.name for tool in TOOLS])}
+        """ 
+
+        sys_msg = SystemMessage(content=tool_prompt)
+        stack = [sys_msg] + state["messages"]  # Берем последние сообщения включая reasoning
+        
+        # Используем модель С инструментами для выполнения
+        step = llm_with_tools.invoke(stack)
+        print("=== TOOL EXECUTION ===")
+        print(f"Tool calls: {step.tool_calls}")
+        
+        return {
+            "messages": state["messages"] + [step],
+            "current_step": current_step + 1 if step.tool_calls else current_step,
+            "reasoning_done": False  # Сбрасываем для следующего шага
+        }
+    
 def should_continue(state : AgentState) -> bool:
     
     last_message = state["messages"][-1]
@@ -235,67 +269,48 @@ def should_continue(state : AgentState) -> bool:
     plan = state.get("plan", None)
     current_step = state.get("current_step", 0)
 
-    if plan and current_step >= len(plan.steps):
-        return "final_answer"
-
-
+    #ПРИОРИТЕТ 1: Если есть tool_calls - выполняем их
+    if hasattr(last_message, "tool_calls") and last_message.tool_calls:
+        return "tools"
+    
+    # ПРИОРИТЕТ 2: Явный сигнал завершения
     if hasattr(last_message, "content") and "<FINAL_ANSWER>" in last_message.content:
         return "final_answer"
-    elif hasattr(last_message, "tool_calls") and last_message.tool_calls:
-        return "tools" 
-    elif not reasoning_done and hasattr(last_message, 'content') and "<REASONING>" in last_message.content:
+    
+    # ПРИОРИТЕТ 3: Логика reasoning/execution
+    if not reasoning_done and hasattr(last_message, 'content') and "<REASONING>" in last_message.content:
         # Reasoning выполнен, но инструменты еще не вызваны
         return "agent"
     elif reasoning_done:
         # Reasoning выполнен, теперь нужно вызвать инструменты
         return "agent"
-    else:
+    elif not reasoning_done:
         # Нужно сделать reasoning
         return "agent"
+    
+    # ПРИОРИТЕТ 4: Проверяем завершение плана (только если нет активных tool_calls)
+    if plan and current_step >= len(plan.steps):
+        return "final_answer"
+    
+    # По умолчанию продолжаем выполнение
+    return "agent"
 
 # 6. Добавить отладочную информацию в TOOL_NODE
 class DebuggingToolNode(ToolNode):
     def __init__(self, tools):
         super().__init__(tools)
-
+    
     def __call__(self, state):
-        log_stage("TOOL NODE", subtitle="Dispatching tool calls", icon="🛠️")
-        try:
-            result = super().__call__(state)
-            log_stage("TOOL NODE", subtitle="Tool execution completed", icon="✅")
-            return result
-        except Exception as exc:
-            log_stage("TOOL ERROR", subtitle=f"{type(exc).__name__}: {exc}", icon="❌")
-            messages = state.get("messages", [])
-            last_message = messages[-1] if messages else None
-            tool_calls = getattr(last_message, "tool_calls", []) if last_message else []
-
-            error_messages = []
-            for call in tool_calls:
-                error_messages.append(
-                    ToolMessage(
-                        content=f"ERROR: {type(exc).__name__}: {exc}",
-                        tool_call_id=call.get("id") or "unknown_call",
-                        name=call.get("name"),
-                    )
-                )
-
-            if not error_messages:
-                error_messages.append(
-                    ToolMessage(
-                        content=f"ERROR: {type(exc).__name__}: {exc}",
-                        tool_call_id="unknown_call",
-                    )
-                )
-
-            return {"messages": messages + error_messages}
+        print("=== TOOL EXECUTION STARTED ===")
+        result = super().__call__(state)
+        print("=== TOOL EXECUTION COMPLETED ===")
+        return result
     
 
-
 def enhanced_finalizer(state: AgentState) -> AgentState:
     """Generate comprehensive execution report for critic evaluation."""
-    log_stage("FINALIZER", subtitle="Compiling execution report", icon="📄")
-
+    print("=== GENERATING EXECUTION REPORT ===")
+    
     # Extract tool execution information
     tools_executed = []
     data_sources = []
@@ -320,22 +335,20 @@ def enhanced_finalizer(state: AgentState) -> AgentState:
     plan = state.get("plan")
     approach_used = "Direct execution"
     assumptions_made = []
-    plan_overview = ""
-
+    
     if plan:
-        approach_used = f"{plan.task_type} plan – {plan.summary}"
+        approach_used = f"{plan.task_type} approach with {len(plan.steps)} steps"
         assumptions_made = plan.assumptions
-        plan_overview = format_plan_overview(plan)
     
     # Generate structured report (КОСТЫЛЬ ЗДЕСЬ!)
     report_generator_prompt = f"""
     Generate a comprehensive execution report for the following query processing:
 
     ORIGINAL QUERY: {state['query']}
-
+    
     EXECUTION CONTEXT:
     - Complexity Level: {state.get('complexity_assessment', {}).level}
-    - Plan Used: {plan_overview if plan_overview else 'direct response'}
+    - Plan Used: {plan if plan else {}}
     - Tools Executed: {tools_executed}
     - Available Files: {list(state.get('file_contents', {}).keys())}
     
@@ -362,18 +375,13 @@ def enhanced_finalizer(state: AgentState) -> AgentState:
         HumanMessage(content="Generate the execution report.")
     ])
     
-    log_key_values(
-        [
-            ("confidence", execution_report.confidence_level),
-            ("findings", str(len(execution_report.key_findings))),
-            ("sources", str(len(execution_report.data_sources))),
-        ]
-    )
-
+    print(f"Report generated - Confidence: {execution_report.confidence_level}")
+    print(f"Key findings: {len(execution_report.key_findings)}")
+    print(f"Data sources: {len(execution_report.data_sources)}")
+    
     # Format final answer for user
     formatted_answer = format_final_answer(execution_report, state.get('complexity_assessment', {}))
-    log_stage("FINAL ANSWER PREVIEW", icon="📬")
-    print(formatted_answer)
+    print(execution_report)
     return {
         "execution_report": execution_report,
         "final_answer": formatted_answer
@@ -382,25 +390,23 @@ def enhanced_finalizer(state: AgentState) -> AgentState:
 
 def simple_executor(state: AgentState) -> AgentState:
     """Handle simple queries directly without planning."""
-    log_stage("SIMPLE EXECUTION", subtitle="Handling low-complexity query", icon="⚡")
-
+    print("=== SIMPLE EXECUTION ===")
+    
     # For simple queries, use the LLM with tools directly
     simple_prompt = f"""
     Answer this simple query directly and efficiently: {state['query']}
-
-    Stay factual, cite tools only if you actually call them, and avoid inventing files or URLs.
-    Known files: {list(state.get('file_contents', {}).keys())}
-    If no tool is required, respond immediately with the final answer.
+    
+    You have access to tools if needed, but try to answer directly when possible.
+    If you need files, they are available at: {list(state.get('file_contents', {}).keys())}
+    
+    Provide a clear, concise answer.
     """
-
+    
     response = llm_with_tools.invoke([
         SystemMessage(content=simple_prompt),
         HumanMessage(content=state['query'])
     ])
     
-    log_stage("SIMPLE EXECUTION OUTPUT", icon="📬")
-    print(response.content)
-
     return {
         "messages": state["messages"] + [response],
         "final_answer": response.content
@@ -419,8 +425,8 @@ def should_use_planning(state: AgentState) -> str:
 
 def critic_evaluator(state: AgentState) -> AgentState:
     """Enhanced critic that evaluates execution reports."""
-    log_stage("CRITIC", subtitle="Evaluating execution report", icon="🔍")
-
+    print("=== ENHANCED ANSWER CRITIQUE ===")
+    
     report = state.get("execution_report")
     critic_llm = llm.with_structured_output(CritiqueFeedback)
     
@@ -440,22 +446,15 @@ def critic_evaluator(state: AgentState) -> AgentState:
         HumanMessage(content="Evaluate this execution report thoroughly.")
     ])
     
-    log_key_values(
-        [
-            ("quality", f"{critique.quality_score}/10"),
-            ("complete", str(critique.is_complete)),
-            ("accurate", str(critique.is_accurate)),
-        ]
-    )
-
+    print(f"Quality Score: {critique.quality_score}/10")
+    print(f"Complete: {critique.is_complete}")
+    print(f"Accurate: {critique.is_accurate}")
+    
     if critique.errors_found:
-        log_stage("CRITIC ISSUES", icon="⚠️")
-        for issue in critique.errors_found:
-            print(f" - {issue}")
-
+        print(f"Issues found: {critique.errors_found}")
+    
     if critique.needs_replanning:
-        log_stage("CRITIC REPLAN", subtitle="Replanning requested", icon="♻️")
-        print(critique.replan_instructions)
+        print(f"Replanning needed: {critique.replan_instructions}")
     
     return {
         "critique_feedback": critique,
@@ -469,63 +468,64 @@ def should_replan(state: AgentState) -> str:
     critique = state.get("critique_feedback")
     iteration_count = state.get("iteration_count", 0)
     max_iterations = state.get("max_iterations", 3)
+    
 
-    subtitle = f"Iteration {iteration_count}/{max_iterations}"
-    log_stage("REPLAN DECISION", subtitle=subtitle, icon="🧭")
-    if critique:
-        log_key_values(
-            [
-                ("quality", str(critique.quality_score)),
-                ("needs_replanning", str(critique.needs_replanning)),
-            ]
-        )
+    print(f"=== REPLAN DECISION ===")
+    print(f"Iteration: {iteration_count}/{max_iterations}")
+    print(f"Quality score: {critique.quality_score if critique else 'N/A'}")
+    print(f"Needs replanning: {critique.needs_replanning if critique else 'N/A'}")
 
     if not critique:
         return "end"
-
+    
     # Stop if max iterations reached
     if iteration_count >= max_iterations:
-        log_stage("REPLAN DECISION", subtitle="Max iterations reached", icon="🛑")
+        print(f"Max iterations ({max_iterations}) reached. Accepting current answer.")
         return "end"
-
+    
     # Accept if quality is good enough
     if critique.quality_score >= 7 or not critique.needs_replanning:
-        log_stage("REPLAN DECISION", subtitle="Accepting current answer", icon="✅")
+        print("Quality acceptable, ending execution")
         return "end"
-
+    
     # Replan if quality is poor and we haven't exceeded max iterations
     if critique.needs_replanning and iteration_count < max_iterations:
-        log_stage("REPLAN DECISION", subtitle="Triggering replanner", icon="♻️")
+        print("Replanning due to critic feedback...")
         return "replan"
-
+    
     return "end"
 
 def replanner(state: AgentState) -> AgentState:
     """Create a revised plan based on critic feedback."""
-    log_stage("REPLANNER", subtitle="Adjusting plan based on feedback", icon="♻️")
-
+    print("=== REPLANNING ===")
+    
     critique = state["critique_feedback"]
     previous_plan = state.get("plan")
-
-    previous_summary = previous_plan.summary if previous_plan else "no previous plan"
-    issues = ", ".join(critique.errors_found) if critique.errors_found else "none"
-    improvements = ", ".join(critique.suggested_improvements) if critique.suggested_improvements else "none"
-    extra_context = (
-        f"Replanning requested by critic. Previous plan summary: {previous_summary}. "
-        f"Critic score: {critique.quality_score}/10. Issues: {issues}. "
-        f"Improvements to address: {improvements}. Specific instructions: "
-        f"{critique.replan_instructions or 'none'}"
-    )
-
-    replan_prompt = _build_planner_prompt(state, extra_context=extra_context)
-
+    
+    replan_prompt = f"""
+    {SYSTEM_PROMPT_PLANNER}
+    
+    REPLANNING CONTEXT:
+    Original Query: {state['query']}
+    Previous Plan: {previous_plan if previous_plan else {}}
+    
+    CRITIC FEEDBACK:
+    - Quality Score: {critique.quality_score}/10
+    - Issues Found: {critique.errors_found}
+    - Missing Elements: {critique.missing_elements}
+    - Improvement Suggestions: {critique.suggested_improvements}
+    - Specific Instructions: {critique.replan_instructions}
+    
+    Create a REVISED plan that addresses these issues. Focus on fixing the identified problems.
+    """
+    
     revised_plan = planner_llm.invoke([
         SystemMessage(content=replan_prompt),
         HumanMessage(content="Create a revised plan based on the feedback.")
     ])
-
-    display_plan(revised_plan)
-
+    
+    print("Plan revised based on critic feedback")
+    
     # Очищаем историю сообщений от неполных tool_calls
     current_messages = state.get("messages", [])
     cleaned_messages = clean_message_history(current_messages)
@@ -540,12 +540,8 @@ def replanner(state: AgentState) -> AgentState:
                 isinstance(msg, HumanMessage)):
                 essential_messages.append(msg)
     
-    log_stage(
-        "REPLANNER",
-        subtitle=f"Cleaned history: {len(current_messages)} → {len(essential_messages)}",
-        icon="🧹",
-    )
-
+    print(f"Cleaned message history: {len(current_messages)} -> {len(essential_messages)} messages")
+    
     return {
         "plan": revised_plan,
         "current_step": 0,
@@ -557,24 +553,21 @@ def replanner(state: AgentState) -> AgentState:
 
 def complexity_assessor(state: AgentState) -> AgentState:
     """Assess query complexity and determine if planning is needed."""
-    log_stage("COMPLEXITY", subtitle="Assessing task difficulty", icon="📊")
-
+    print("=== COMPLEXITY ASSESSMENT ===")
+    
     complexity_llm = llm.with_structured_output(ComplexityLevel)
-
+    
     assessment_message = [
         SystemMessage(content=COMPLEXITY_ASSESSOR_PROMPT.strip()),
         HumanMessage(content=f"Query: {state['query']}")
     ]
-
+    
     assessment = complexity_llm.invoke(assessment_message)
-    log_key_values(
-        [
-            ("level", assessment.level),
-            ("needs_planning", str(assessment.needs_planning)),
-            ("reasoning", assessment.reasoning),
-        ]
-    )
-
+    
+    print(f"Complexity: {assessment.level}")
+    print(f"Needs planning: {assessment.needs_planning}")
+    print(f"Reasoning: {assessment.reasoning}")
+    
     return {
         "complexity_assessment": assessment,
         "messages": state["messages"] + assessment_message

src/prompts/prompts.py

@@ -24,7 +24,7 @@ Return a single JSON object with this structure:
 }}
 
 Ground rules:
-- Prefer 1–3 steps. Only add a step if it changes the outcome.
+- Prefer 1–3 steps. Only add a step if it changes the outcome. For complex tasks, up to 5-7 steps is okay.
 - Use tool names exactly as listed. If no tool is needed, set "tool": null.
 - Never assume files or URLs exist—plan to search/download before analysing.
 - Skip download steps when the required file is already provided.
@@ -130,5 +130,5 @@ Confidence: {confidence}
 Limitations: {limitations}
 Final Answer: {answer}
 
-Provide detailed critique focusing on what works well and what could be improved.
+Provide detailed critique focusing on what works well and what could be improved. REMEMBER: if the task is enough simple, just say "NO CRITIC NEEDED".
 """

src/schemas.py

@@ -1,6 +1,5 @@
 from typing import List, Optional, Literal
-from pydantic import BaseModel, Field
-
+from pydantic import BaseModel, Field, field_validator
 
 class ComplexityLevel(BaseModel):
     level: Literal["simple", "moderate", "complex"] = Field(description="Complexity level of the query")
@@ -18,8 +17,6 @@ class CritiqueFeedback(BaseModel):
     needs_replanning: bool = Field(description="Whether the plan should be revised")
     replan_instructions: Optional[str] = Field(default=None, description="Instructions for replanning")
 
-
-
 TaskType = Literal["info", "calc", "table", "doc_qa", "image_qa", "multi_hop"]
 
 class PlanStep(BaseModel):
@@ -30,6 +27,19 @@ class PlanStep(BaseModel):
     expected_result: str = Field(description="How to confirm the step succeeded")
     on_fail: str = Field(default="replan", description="Fallback action if the step fails (replan or stop)")
 
+    @field_validator("tool", mode="before")
+    @classmethod
+    def normalize_tool(cls, value: Optional[str]) -> Optional[str]:
+        """Ensure blank or null-like values are interpreted as no tool."""
+
+        if value is None:
+            return None
+        if isinstance(value, str):
+            cleaned = value.strip()
+            if not cleaned or cleaned.lower() in {"null", "none"}:
+                return None
+            return cleaned
+        return value
 
 class PlannerPlan(BaseModel):
     task_type: TaskType

src/utils/utils.py

@@ -1,10 +1,9 @@
 from typing import Iterable, Optional
-
+from langchain_openai import ChatOpenAI
 from langchain_core.messages import AIMessage, HumanMessage, SystemMessage, ToolMessage
 
 from schemas import ComplexityLevel, ExecutionReport, PlannerPlan
 from prompts.prompts import COMPLEXITY_ASSESSOR_PROMPT
-from config import llm
 from state import AgentState
 
 def log_stage(title: str, subtitle: Optional[str] = None, icon: str = "🚀") -> None:
@@ -52,6 +51,8 @@ def display_plan(plan: PlannerPlan) -> None:
         print(f"   {step.id} → {step.goal}")
         if step.tool:
             print(f"      tool: {step.tool}")
+        else:
+            print("      tool: (none)")
         if step.inputs:
             print(f"      inputs: {step.inputs}")
         print(f"      expected: {step.expected_result}")
@@ -138,7 +139,7 @@ def complexity_assessor(state: AgentState) -> AgentState:
     """Assess query complexity and determine if planning is needed."""
     print("=== COMPLEXITY ASSESSMENT ===")
     
-    complexity_llm = llm.with_structured_output(ComplexityLevel)
+    complexity_llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.25).with_structured_output(ComplexityLevel)
     
     assessment_message = [
         SystemMessage(content=COMPLEXITY_ASSESSOR_PROMPT.strip()),

src/workflow_test.ipynb

@@ -2,14 +2,14 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "d:\\REGNUM_SPECTRARUM_updated\\.venv\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "d:\\ankelodon_multiagent_system\\.venv\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
       "  from .autonotebook import tqdm as notebook_tqdm\n"
      ]
     }
@@ -21,7 +21,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -30,46 +30,188 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "=== USER QUERY TRANSFERED TO AGENT ===\n",
+      "\n",
+      "💡 ════════════════════\n",
+      "💡  USER QUERY \n",
+      "💡 ════════════════════\n",
+      "   • files: none provided\n",
       "=== COMPLEXITY ASSESSMENT ===\n",
-      "Complexity: simple\n",
-      "Needs planning: False\n",
-      "Reasoning: This query is a straightforward arithmetic calculation that can be answered immediately without any tools or complex reasoning.\n",
-      "=== SIMPLE EXECUTION ===\n",
+      "Complexity: complex\n",
+      "Needs planning: True\n",
+      "Reasoning: This query involves multiple steps: first, gathering information about Nikita Miroshnichenko, which may require searching through various sources; second, verifying his affiliation with UNIL and any working experience at EPFL; and third, synthesizing this information into a coherent summary. The need to cross-reference information adds to the complexity, as it requires careful reasoning to ensure accuracy.\n",
+      "\n",
+      "🧭 ════════════════════\n",
+      "🧭  PLANNING \n",
+      "🧭 ════════════════════\n",
+      "\n",
+      "🧭 ════════════════════\n",
+      "🧭  PLANNER OUTPUT \n",
+      "🧭 ════════════════════\n",
+      "Task type: info\n",
+      "Summary: I will perform a web search to gather information about Nikita Miroshnichenko, including his background as a student at UNIL and any working experience at EPFL.\n",
+      "Steps:\n",
+      "   s1 → Search for information about Nikita Miroshnichenko to confirm his background and work experience.\n",
+      "      tool: web_search\n",
+      "      inputs: Nikita Miroshnichenko UNIL EPFL\n",
+      "      expected: Find relevant information confirming his student status and any work experience at EPFL.\n",
+      "      on_fail: replan\n",
+      "Answer guidelines: Provide a concise summary based on the information found, including citations if applicable.\n",
+      "\n",
+      "🤖 ════════════════════\n",
+      "🤖  EXECUTION \n",
+      "🤖 ════════════════════\n",
+      "🤖 Step 1/1: Search for information about Nikita Miroshnichenko to confirm his background and work experience.\n",
+      "   • step_id: s1\n",
+      "   • tool: web_search\n",
+      "   • expected: Find relevant information confirming his student status and any work experience at EPFL.\n",
+      "\n",
+      "🧠 ════════════════════\n",
+      "🧠  REASONING \n",
+      "🧠 ════════════════════\n",
+      "🧠 s1\n",
+      "<REASONING> The query requires gathering information about Nikita Miroshnichenko, specifically his background as a student at UNIL and any work experience at EPFL. This involves performing a web search to find relevant details about him, which will help in writing a short summary. The first step will be to use the web_search tool to collect this information. The expected outcome is to obtain sufficient data to confirm his educational background and work experience, which will then allow for the creation of a summary. Since this is a research task that requires external information, it is classified as a moderate complexity task. </REASONING>\n",
+      "=== REASONING STEP ===\n",
+      "{\n",
+      "  \"task_type\": \"info\",\n",
+      "  \"summary\": \"The plan involves searching for information about Nikita Miroshnichenko to confirm his background as a student at UNIL and any work experience at EPFL.\",\n",
+      "  \"assumptions\": [\"Nikita Miroshnichenko is a student at UNIL\", \"There may be publicly available information regarding his work experience at EPFL\"],\n",
+      "  \"steps\": [\n",
+      "    {\n",
+      "      \"id\": \"s1\",\n",
+      "      \"goal\": \"Search for information about Nikita Miroshnichenko to confirm his background and work experience.\",\n",
+      "      \"tool\": \"web_search\",\n",
+      "      \"inputs\": \"Nikita Miroshnichenko UNIL EPFL\",\n",
+      "      \"expected_result\": \"Find relevant information confirming his student status and any work experience at EPFL.\",\n",
+      "      \"on_fail\": \"replan\"\n",
+      "    }\n",
+      "  ],\n",
+      "  \"answer_guidelines\": \"Provide a summary of the findings, including citations for any sources used.\"\n",
+      "}\n",
+      "\n",
+      "🤖 ════════════════════\n",
+      "🤖  EXECUTION \n",
+      "🤖 ════════════════════\n",
+      "🤖 Step 1/1: Search for information about Nikita Miroshnichenko to confirm his background and work experience.\n",
+      "   • step_id: s1\n",
+      "   • tool: web_search\n",
+      "   • expected: Find relevant information confirming his student status and any work experience at EPFL.\n",
+      "=== TOOL EXECUTION ===\n",
+      "Tool calls: [{'name': 'web_search', 'args': {'query': 'Nikita Miroshnichenko UNIL EPFL'}, 'id': 'call_TJN5zTZWXac12m0so0FrKpOr', 'type': 'tool_call'}]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "d:\\ankelodon_multiagent_system\\src\\tools\\tools.py:228: LangChainDeprecationWarning: The class `TavilySearchResults` was deprecated in LangChain 0.3.25 and will be removed in 1.0. An updated version of the class exists in the :class:`~langchain-tavily package and should be used instead. To use it run `pip install -U :class:`~langchain-tavily` and import as `from :class:`~langchain_tavily import TavilySearch``.\n",
+      "  raw_results = TavilySearchResults(max_results=max_results).invoke(query)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "✅ ════════════════════\n",
+      "✅  PLAN COMPLETE \n",
+      "✅ ════════════════════\n",
+      "✅ All steps executed\n",
       "=== GENERATING EXECUTION REPORT ===\n",
       "Report generated - Confidence: high\n",
       "Key findings: 2\n",
-      "Data sources: 0\n",
-      "query_summary='The user requested the result of the arithmetic expression 2 + 2 - 2 + 2.' approach_used='The query was evaluated using basic arithmetic operations, following the standard order of operations.' tools_executed=[] key_findings=['The expression was simplified step-by-step: 2 + 2 = 4, then 4 - 2 = 2, and finally 2 + 2 = 4.', 'The final result of the expression is 4.'] data_sources=[] assumptions_made=['The user intended to use standard arithmetic rules without any additional context or modifications.'] confidence_level='high' limitations=['The query was straightforward, and no complex tools or external data sources were required.', 'The execution context did not involve any ambiguity or alternative interpretations.'] final_answer='4'\n",
+      "Data sources: 1\n",
+      "query_summary='The user requested information about Nikita Miroshnichenko, a student from UNIL, and inquired about his working experience at EPFL.' approach_used=\"A web search was conducted to gather relevant information regarding Nikita Miroshnichenko's background as a student at UNIL and any work experience he may have at EPFL.\" tools_executed=[ToolExecution(tool_name='web_search', arguments=\"{'query': 'Nikita Miroshnichenko UNIL EPFL'}\", call_id='call_TJN5zTZWXac12m0so0FrKpOr')] key_findings=['Nikita Miroshnichenko is a student at UNIL.', 'He has been associated with EPFL, confirming his work experience there.'] data_sources=['https://topline.com/people/nikita-miroshnichenko-182776498'] assumptions_made=[] confidence_level='high' limitations=['The information retrieved is based on available online sources, which may not be exhaustive or fully up-to-date.'] final_answer='Nikita Miroshnichenko is a student at UNIL and has confirmed working experience at EPFL.'\n",
       "=== ENHANCED ANSWER CRITIQUE ===\n",
-      "Quality Score: 8/10\n",
+      "Quality Score: 6/10\n",
       "Complete: True\n",
       "Accurate: True\n",
       "=== REPLAN DECISION ===\n",
       "Iteration: 1/10\n",
-      "Quality score: 8\n",
+      "Quality score: 6\n",
       "Needs replanning: False\n",
       "Quality acceptable, ending execution\n"
      ]
     }
    ],
    "source": [
-    "result = graph.invoke({\"query\" : \"2+2-2+2?\", \"current_step\": 0, \"reasoning_done\": False, \"files\" : [], \"files_contents\" : {}, \"iteration_count\" : 0, \"max_iterations\" : 10, \"plan\" : None} , config = config)"
+    "query = \"Find info about Nikita Miroshnichenko, its a student from UNIL, and write a short summary about him. Is it true that he has a working experience at EPFL?\"\n",
+    "result = graph.invoke({\"query\" : query, \"current_step\": 0, \"reasoning_done\": False, \"files\" : [], \"files_contents\" : {}, \"iteration_count\" : 0, \"max_iterations\" : 10, \"plan\" : None} , config = config)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "FINAL ANSWER: Nikita Miroshnichenko is a student at UNIL and has confirmed working experience at EPFL.\n",
+      "\n",
+      "SUMMARY:\n",
+      "The user requested information about Nikita Miroshnichenko, a student from UNIL, and inquired about his working experience at EPFL.\n",
+      "\n",
+      "KEY FINDINGS:\n",
+      "• Nikita Miroshnichenko is a student at UNIL.\n",
+      "• He has been associated with EPFL, confirming his work experience there.\n",
+      "\n",
+      "SOURCES:\n",
+      "• https://topline.com/people/nikita-miroshnichenko-182776498\n",
+      "\n",
+      "LIMITATIONS:\n",
+      "• The information retrieved is based on available online sources, which may not be exhaustive or fully up-to-date.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(result[\"final_answer\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'messages': [SystemMessage(content='You are a COMPLEXITY ASSESSOR for a multi-tool agent system.\\nYour job is to analyze user queries and determine their complexity level and processing requirements.\\n\\nCOMPLEXITY LEVELS:\\n1. SIMPLE: Direct questions that can be answered immediately without tools or with single tool use\\n   - Examples: \"What is 2+2?\", \"Define photosynthesis\", \"What\\'s the capital of France?\"\\n   \\n2. MODERATE: Questions requiring 1-3 tool calls or basic analysis\\n   - Examples: \"Search for recent news about AI\", \"Analyze this CSV file\", \"What\\'s the weather tomorrow?\"\\n   \\n3. COMPLEX: Multi-step problems requiring planning, multiple tools, or sophisticated reasoning\\n   - Examples: Research tasks, multi-file analysis, calculations with dependencies, creative projects\\n\\nASSESSMENT CRITERIA:\\n- Number of steps likely needed\\n- Tool complexity and dependencies\\n- Data processing requirements\\n- Need for intermediate reasoning\\n- Risk of failure without proper planning\\n\\nRULES:\\n- SIMPLE queries bypass planning entirely\\n- MODERATE queries may use lightweight planning\\n- COMPLEX queries require full planning with fallbacks\\n- When in doubt, err toward higher complexity\\n\\nAnalyze the query and respond with your assessment.', additional_kwargs={}, response_metadata={}, id='11b7e36b-63f4-4dab-b911-19a122ded253'),\n",
+       "  HumanMessage(content='Query: Find info about Nikita Miroshnichenko, its a student from UNIL, and write a short summary about him. Is it true that he has a working experience at EPFL?', additional_kwargs={}, response_metadata={}, id='33ed5c6b-c4af-4080-8531-afa04709ae79'),\n",
+       "  SystemMessage(content='You are the planner of a multi-tool agent. Build a short, realistic plan that the executor can follow.\\n\\nAvailable tools: add, analyze_csv_file, analyze_docx_file, analyze_excel_file, analyze_image_file, analyze_pdf_file, analyze_txt_file, arxiv_search, divide, download_file_from_url, multiply, power, safe_code_run, subtract, vision_qa_gemma, web_search, wiki_search\\nKnown local files: none provided\\nAdditional context: None\\n\\nReturn a single JSON object with this structure:\\n{\\n  \"task_type\": \"info|calc|table|doc_qa|image_qa|multi_hop\",\\n  \"summary\": \"One sentence on the chosen approach\",\\n  \"assumptions\": [\"optional clarifications\"],\\n  \"steps\": [\\n    {\\n      \"id\": \"s1\",\\n      \"goal\": \"Action to take and why it helps\",\\n      \"tool\": \"tool_name_or_null\",\\n      \"inputs\": \"Key parameters or references (files, URLs, prior steps)\",\\n      \"expected_result\": \"How you know the step succeeded\",\\n      \"on_fail\": \"replan|stop\"\\n    }\\n  ],\\n  \"answer_guidelines\": \"Reminders for the final response (citations, format, units, etc.)\"\\n}\\n\\nGround rules:\\n- Prefer 1–3 steps. Only add a step if it changes the outcome. For complex tasks, up to 5-7 steps is okay.\\n- Use tool names exactly as listed. If no tool is needed, set \"tool\": null.\\n- Never assume files or URLs exist—plan to search/download before analysing.\\n- Skip download steps when the required file is already provided.\\n- Ensure later steps only depend on results created by earlier steps.\\n- If the query is trivial, return an empty steps list and explain the direct answer in \"summary\".', additional_kwargs={}, response_metadata={}, id='a2291408-86bd-4a5a-ad97-88ba7ca26f8a'),\n",
+       "  HumanMessage(content='Find info about Nikita Miroshnichenko, its a student from UNIL, and write a short summary about him. Is it true that he has a working experience at EPFL?', additional_kwargs={}, response_metadata={}, id='02bdaf14-e770-4903-8bd2-ec4bce7070a0'),\n",
+       "  AIMessage(content='{\\n  \"task_type\": \"info\",\\n  \"summary\": \"The plan involves searching for information about Nikita Miroshnichenko to confirm his background as a student at UNIL and any work experience at EPFL.\",\\n  \"assumptions\": [\"Nikita Miroshnichenko is a student at UNIL\", \"There may be publicly available information regarding his work experience at EPFL\"],\\n  \"steps\": [\\n    {\\n      \"id\": \"s1\",\\n      \"goal\": \"Search for information about Nikita Miroshnichenko to confirm his background and work experience.\",\\n      \"tool\": \"web_search\",\\n      \"inputs\": \"Nikita Miroshnichenko UNIL EPFL\",\\n      \"expected_result\": \"Find relevant information confirming his student status and any work experience at EPFL.\",\\n      \"on_fail\": \"replan\"\\n    }\\n  ],\\n  \"answer_guidelines\": \"Provide a summary of the findings, including citations for any sources used.\"\\n}', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 206, 'prompt_tokens': 1088, 'total_tokens': 1294, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_51db84afab', 'id': 'chatcmpl-CHEdmytbl8Nei62qo9Ti4se6AOc5O', 'service_tier': 'default', 'finish_reason': 'stop', 'logprobs': None}, id='run--bbddcd4a-f737-4033-b789-adcf6c3bacb5-0', usage_metadata={'input_tokens': 1088, 'output_tokens': 206, 'total_tokens': 1294, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}}),\n",
+       "  AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_TJN5zTZWXac12m0so0FrKpOr', 'function': {'arguments': '{\"query\":\"Nikita Miroshnichenko UNIL EPFL\"}', 'name': 'web_search'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 25, 'prompt_tokens': 2672, 'total_tokens': 2697, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 1920}}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_560af6e559', 'id': 'chatcmpl-CHEdrHAP7W9cDsebqQu7iAIVGl2OF', 'service_tier': 'default', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run--9d9e841f-b6eb-4df1-8695-3cb5d35e83b7-0', tool_calls=[{'name': 'web_search', 'args': {'query': 'Nikita Miroshnichenko UNIL EPFL'}, 'id': 'call_TJN5zTZWXac12m0so0FrKpOr', 'type': 'tool_call'}], usage_metadata={'input_tokens': 2672, 'output_tokens': 25, 'total_tokens': 2697, 'input_token_details': {'audio': 0, 'cache_read': 1920}, 'output_token_details': {'audio': 0, 'reasoning': 0}}),\n",
+       "  ToolMessage(content='{\"query\": \"Nikita Miroshnichenko UNIL EPFL\", \"provider\": \"tavily\", \"items\": [{\"url\": \"https://topline.com/people/nikita-miroshnichenko-182776498\", \"title\": \"Nikita Miroshnichenko - Topline\", \"snippet\": \"###### The International Festival of Engineering Science and Technology in Tunisia I-FEST\\\\u00b2 (Silver medal)\\\\n\\\\n###### Molecular phylogenetic&bioinformatics course\\\\n\\\\n###### Molecular biology&genetics course\\\\n\\\\n###### Python programming course\\\\n\\\\n#### Experience\\\\n\\\\n##### University of Lausanne - UNIL\\\\n\\\\n##### Student Laboratory Assistant\\\\n\\\\n##### EPFL (\\\\u00c9cole polytechnique f\\\\u00e9d\\\\u00e9rale de Lausanne)\\\\n\\\\n##### Laboratory A\\\\u2026\", \"published\": null, \"source\": \"topline.com\"}, {\"url\": \"https://cdn5.f-cdn.com/files/download/223843566/Nikita_Miroshnichenko_technical_CV_2024.pdf\", \"title\": \"[PDF] Nikita Miroshnichenko\", \"snippet\": \"development in this field. If possible, I will be glad to apply my work experience in biotech/neurotech-oriented projects. NOVEMBER 2023 \\\\u2013 PRESENT Research Assistant. Computational Biology and Cancer Genomics Group Department of Computational Biology | UNIL. Lausanne \\\\u2022 Processing raw single-cell RNAseq data, building bioinformatics pipelines for oncology and genomic research. \\\\u2022 Development of a P\\\\u2026\", \"published\": null, \"source\": \"f-cdn.com\"}, {\"url\": \"https://ch.linkedin.com/in/nikita-miroshnichenko\", \"title\": \"Nikita Miroshnichenko \\\\u2013 AI Engineer | Biotech Enthusiast - LinkedIn\", \"snippet\": \"Nikita Miroshnichenko. AI Engineer | Biotech Enthusiast | Researcher | Entrepreneur. University of Lausanne - UNIL Taras Shevchenko National University of Kyiv\", \"published\": null, \"source\": \"linkedin.com\"}, {\"url\": \"https://www.transfermarkt.com/nikita-miroshnichenko/profil/spieler/561855\", \"title\": \"Nikita Miroshnichenko - Player profile 25/26 - Transfermarkt\", \"snippet\": \"Transfermarkt\\\\nUEFA Champions League\\\\nPremier League\\\\nLaLiga\\\\nSerie A\\\\nBundesliga\\\\nLigue 1\\\\n\\\\nNikita Miroshnichenko\\\\n\\\\n# #18 Nikita Miroshnichenko\\\\n\\\\nShinnik Yaroslavl\\\\n1.Division1.Division\\\\nRussiaSecond Tier\\\\nNikita Miroshnichenko\\\\n\\\\nfnl.pro\\\\n\\\\n+\\\\nRussia \\\\nSalavat, ... \\\\nRussia Russia\\\\nRussiaRussia U17\\\\n\\\\nLast update: 02.06.2025\\\\n\\\\n## Player data\\\\n\\\\nRussia\\\\nRussia  Russia\\\\nShinnik Yaroslavl\\\\n\\\\n## Stats of Nikita Miroshnichenko\\\\n\\\\u2026\", \"published\": null, \"source\": \"transfermarkt.com\"}, {\"url\": \"http://arxiv.org/list/physics.optics/2019-12?skip=125&show=2000\", \"title\": \"Optics Dec 2019 - arXiv\", \"snippet\": \"Cornell University\\\\narxiv logo\\\\n\\\\nHelp | Advanced Search\\\\n\\\\narXiv logo\\\\nCornell University Logo\\\\n\\\\n## quick links\\\\n\\\\n# Optics\\\\n\\\\n## Authors and titles for December 2019\\\\n\\\\narXiv Operational Status   \\\\nGet status notifications via\\\\nemail\\\\nor slack\", \"published\": null, \"source\": \"arxiv.org\"}]}', name='web_search', id='cd84b5bb-27ed-495b-942a-70de16013c44', tool_call_id='call_TJN5zTZWXac12m0so0FrKpOr'),\n",
+       "  AIMessage(content='All plan steps completed. <FINAL_ANSWER>', additional_kwargs={}, response_metadata={}, id='3463b080-aa10-4906-bc0c-4d6e49bb8d8a')],\n",
+       " 'query': 'Find info about Nikita Miroshnichenko, its a student from UNIL, and write a short summary about him. Is it true that he has a working experience at EPFL?',\n",
+       " 'final_answer': 'FINAL ANSWER: Nikita Miroshnichenko is a student at UNIL and has confirmed working experience at EPFL.\\n\\nSUMMARY:\\nThe user requested information about Nikita Miroshnichenko, a student from UNIL, and inquired about his working experience at EPFL.\\n\\nKEY FINDINGS:\\n• Nikita Miroshnichenko is a student at UNIL.\\n• He has been associated with EPFL, confirming his work experience there.\\n\\nSOURCES:\\n• https://topline.com/people/nikita-miroshnichenko-182776498\\n\\nLIMITATIONS:\\n• The information retrieved is based on available online sources, which may not be exhaustive or fully up-to-date.',\n",
+       " 'plan': PlannerPlan(task_type='info', summary='I will perform a web search to gather information about Nikita Miroshnichenko, including his background as a student at UNIL and any working experience at EPFL.', assumptions=[], steps=[PlanStep(id='s1', goal='Search for information about Nikita Miroshnichenko to confirm his background and work experience.', tool='web_search', inputs='Nikita Miroshnichenko UNIL EPFL', expected_result='Find relevant information confirming his student status and any work experience at EPFL.', on_fail='replan')], answer_guidelines='Provide a concise summary based on the information found, including citations if applicable.'),\n",
+       " 'complexity_assessment': ComplexityLevel(level='complex', reasoning='This query involves multiple steps: first, gathering information about Nikita Miroshnichenko, which may require searching through various sources; second, verifying his affiliation with UNIL and any working experience at EPFL; and third, synthesizing this information into a coherent summary. The need to cross-reference information adds to the complexity, as it requires careful reasoning to ensure accuracy.', needs_planning=True, suggested_approach='Begin by searching for Nikita Miroshnichenko on academic and professional platforms to gather relevant information. Verify his student status at UNIL and check for any records of employment or internships at EPFL. Compile the findings into a concise summary.'),\n",
+       " 'current_step': 1,\n",
+       " 'reasoning_done': False,\n",
+       " 'files': [],\n",
+       " 'critique_feedback': CritiqueFeedback(quality_score=6, is_complete=True, is_accurate=True, missing_elements=['Details about the specific role or position held by Nikita Miroshnichenko at EPFL', 'Information on the duration of his work experience at EPFL', 'Any notable projects or contributions made during his time at EPFL'], errors_found=[], suggested_improvements=[\"Include more specific details about Nikita's role at EPFL to provide a clearer picture of his experience.\", 'Add information about the duration of his work experience to contextualize his involvement.', 'Mention any projects or contributions he made during his time at EPFL to enhance the depth of the report.'], needs_replanning=False, replan_instructions=None),\n",
+       " 'iteration_count': 1,\n",
+       " 'max_iterations': 10,\n",
+       " 'execution_report': ExecutionReport(query_summary='The user requested information about Nikita Miroshnichenko, a student from UNIL, and inquired about his working experience at EPFL.', approach_used=\"A web search was conducted to gather relevant information regarding Nikita Miroshnichenko's background as a student at UNIL and any work experience he may have at EPFL.\", tools_executed=[ToolExecution(tool_name='web_search', arguments=\"{'query': 'Nikita Miroshnichenko UNIL EPFL'}\", call_id='call_TJN5zTZWXac12m0so0FrKpOr')], key_findings=['Nikita Miroshnichenko is a student at UNIL.', 'He has been associated with EPFL, confirming his work experience there.'], data_sources=['https://topline.com/people/nikita-miroshnichenko-182776498'], assumptions_made=[], confidence_level='high', limitations=['The information retrieved is based on available online sources, which may not be exhaustive or fully up-to-date.'], final_answer='Nikita Miroshnichenko is a student at UNIL and has confirmed working experience at EPFL.')}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result"
+   ]
   }
  ],
  "metadata": {