first ateempt to finalize node setup

app.log

@@ -49882,3 +49882,32 @@ For troubleshooting, visit: https://python.langchain.com/docs/troubleshooting/er
 2025-06-06 14:35:30:__main__:INFO: Prompt: You are a helpful assistant.
 2025-06-06 14:35:39:__main__:INFO: Greeting added for new user via handle_initial_greeting_load.
 2025-06-06 14:36:20:__main__:INFO: Greeting added for new user via handle_initial_greeting_load.
+2025-06-06 14:36:35:__main__:INFO: Starting the interface
+2025-06-06 14:37:12:__main__:INFO: Greeting added for new user via handle_initial_greeting_load.
+2025-06-06 14:37:17:__main__:INFO: Greeting added for new user via handle_initial_greeting_load.
+2025-06-06 14:37:31:__main__:INFO: Prompt: You are a helpful assistant.
+2025-06-06 14:38:10:__main__:ERROR: Exception occurred
+Traceback (most recent call last):
+  File "/home/user/app/app.py", line 85, in chat_fn
+    async for stream_mode, chunk in graph.astream(
+  File "/usr/local/lib/python3.10/site-packages/langgraph/pregel/__init__.py", line 2677, in astream
+    raise GraphRecursionError(msg)
+langgraph.errors.GraphRecursionError: Recursion limit of 20 reached without hitting a stop condition. You can increase the limit by setting the `recursion_limit` config key.
+For troubleshooting, visit: https://python.langchain.com/docs/troubleshooting/errors/GRAPH_RECURSION_LIMIT
+2025-06-06 14:38:58:__main__:INFO: Prompt: You are a helpful assistant.
+2025-06-06 14:39:30:__main__:INFO: Starting the interface
+2025-06-06 14:39:51:__main__:INFO: Greeting added for new user via handle_initial_greeting_load.
+2025-06-06 14:39:53:__main__:INFO: Greeting added for new user via handle_initial_greeting_load.
+2025-06-06 14:40:01:__main__:INFO: Prompt: You are a helpful assistant.
+2025-06-06 14:40:41:__main__:ERROR: Exception occurred
+Traceback (most recent call last):
+  File "/home/user/app/app.py", line 85, in chat_fn
+    async for stream_mode, chunk in graph.astream(
+  File "/usr/local/lib/python3.10/site-packages/langgraph/pregel/__init__.py", line 2677, in astream
+    raise GraphRecursionError(msg)
+langgraph.errors.GraphRecursionError: Recursion limit of 20 reached without hitting a stop condition. You can increase the limit by setting the `recursion_limit` config key.
+For troubleshooting, visit: https://python.langchain.com/docs/troubleshooting/errors/GRAPH_RECURSION_LIMIT
+2025-06-06 14:42:57:__main__:INFO: Starting the interface
+2025-06-06 14:43:07:__main__:INFO: Greeting added for new user via handle_initial_greeting_load.
+2025-06-06 14:43:08:__main__:INFO: Greeting added for new user via handle_initial_greeting_load.
+2025-06-06 14:43:36:__main__:INFO: Greeting added for new user via handle_initial_greeting_load.

graph.py

@@ -113,108 +113,7 @@ class GraphProcessingState(BaseModel):
     purchasing_complete: bool = Field(default=False)
 
 
-async def planning_node(state: GraphProcessingState, config=None):
-    # Define the system prompt for planning
-    planning_prompt = "Based on the user's idea, create a detailed step-by-step plan to build the DIY product."
-
-    # Combine the planning prompt with any existing prompts
-    if state.prompt:
-        final_prompt = "\n".join([planning_prompt, state.prompt, ASSISTANT_SYSTEM_PROMPT_BASE])
-    else:
-        final_prompt = "\n".join([planning_prompt, ASSISTANT_SYSTEM_PROMPT_BASE])
-
-    # Create the prompt template
-    prompt = ChatPromptTemplate.from_messages(
-        [
-            ("system", final_prompt),
-            MessagesPlaceholder(variable_name="messages"),
-        ]
-    )
 
-    # Bind tools if necessary
-    assistant_tools = []
-    if state.tools_enabled.get("download_website_text", True):
-        assistant_tools.append(download_website_text)
-    if search_enabled and state.tools_enabled.get("tavily_search_results_json", True):
-        assistant_tools.append(tavily_search_tool)
-    assistant_model = model.bind_tools(assistant_tools)
-
-    # Create the chain and invoke it
-    chain = prompt | assistant_model
-    response = await chain.ainvoke({"messages": state.messages}, config=config)
-
-    return {
-        "messages": response
-    }
-
-async def assistant_node(state: GraphProcessingState, config=None):
-    print("\n--- Assistance Node (Debug via print) ---") # Added a newline for clarity
-
-
-    print(f"Prompt: {state.prompt}")
-
-    print(f"Tools Enabled: {state.tools_enabled}")
-    print(f"Search Enabled: {state.search_enabled}")
-    print(f"Next Stage: {state.next_stage}")
-
-
-    # Log boolean completion flags
-    print(f"Idea Complete: {state.idea_complete}")
-    print(f"Brainstorming Complete: {state.brainstorming_complete}")
-    print(f"Planning Complete: {state.planning_complete}")
-    print(f"Drawing Complete: {state.drawing_complete}")
-    print(f"Product Searching Complete: {state.product_searching_complete}")
-    print(f"Purchasing Complete: {state.purchasing_complete}")
-    print("--- End Guidance Node Debug ---") # Added for clarity
-    print(f"\nMessage: {state.messages}")
-    assistant_tools = []
-    if state.tools_enabled.get("download_website_text", True):
-        assistant_tools.append(download_website_text)
-    if search_enabled and state.tools_enabled.get("tavily_search_results_json", True):
-        assistant_tools.append(tavily_search_tool)
-    assistant_model = model.bind_tools(assistant_tools)
-    if state.prompt:
-        final_prompt = "\n".join([state.prompt, ASSISTANT_SYSTEM_PROMPT_BASE])
-    else:
-        final_prompt = ASSISTANT_SYSTEM_PROMPT_BASE
-
-    prompt = ChatPromptTemplate.from_messages(
-        [
-            ("system", final_prompt),
-            MessagesPlaceholder(variable_name="messages"),
-        ]
-    )
-    chain = prompt | assistant_model
-    response = await chain.ainvoke({"messages": state.messages}, config=config)
-
-    for msg in response:
-        if isinstance(msg, HumanMessage):
-            print("Human:", msg.content)
-        elif isinstance(msg, AIMessage):
-            if isinstance(msg.content, list):
-                ai_texts = [part.get("text", "") for part in msg.content if isinstance(part, dict)]
-                print("AI:", " ".join(ai_texts))
-            else:
-                print("AI:", msg.content)
-
-    idea_complete = evaluate_idea_completion(response)
-
-    return {
-        "messages": response,
-        "idea_complete": idea_complete
-    }
-
-    # message = llm_with_tools.invoke(state["messages"])
-    # Because we will be interrupting during tool execution,
-    # we disable parallel tool calling to avoid repeating any
-    # tool invocations when we resume.
-    assert len(response.tool_calls) <= 1
-    idea_complete = evaluate_idea_completion(response)
-
-    return {
-        "messages": response,
-        "idea_complete": idea_complete
-    }
 
 async def guidance_node(state: GraphProcessingState, config=None):
     # Use logger.debug() for verbose debugging information
@@ -313,36 +212,108 @@ async def guidance_node(state: GraphProcessingState, config=None):
         "next_stage": incomplete[0] if incomplete else None
     }
 
-# def assistant_cond_edge(state: GraphProcessingState):
-#     last_message = state.messages[-1]
-#     if hasattr(last_message, "tool_calls") and last_message.tool_calls:
-#         logger.info(f"Tool call detected: {last_message.tool_calls}")
-#         return "tools"
-#     return END
-def assistant_routing(state: GraphProcessingState) -> str:
-    last_message = state.messages[-1]
-    if hasattr(last_message, "tool_calls") and last_message.tool_calls:
-        logger.info("Tool call detected. Routing to 'tools' node.")
-        return "tools"
-    elif state.idea_complete:
-        logger.info("Idea is complete. Routing to 'planning_node'.")
-        return "planning_node"
+async def brainstorming_node(state: GraphProcessingState, config=None):
+    print("\n--- Brainstorming Node ---")
+    if not model:
+        return {"messages": [AIMessage(content="Model not available for brainstorming.")]}
+
+    # Define the system prompt for brainstorming
+    # This prompt guides the LLM on its role, constraints, and how to signal completion or use tools.
+    brainstorming_system_prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system",
+             "You are a brainstorming assistant for DIY projects. Your goal is to help the user finalize a single, specific DIY project idea. "
+             "The project idea MUST satisfy these critical criteria:\n"
+             "1. Buildable by an average person with basic DIY skills.\n"
+             "2. Uses only materials and basic tools commonly available in general hardware stores, craft stores, or supermarkets worldwide. (e.g., wood, screws, glue, paint, fabric, cardboard, basic hand tools like screwdrivers, hammers, saws, drills. AVOID specialized electronic components, 3D printing, specific brand items not universally available, or complex machinery.)\n"
+             "3. The final product should be a tangible item.\n\n"
+             "Your interaction flow:\n"
+             "- Engage with the user to understand their interests or initial thoughts.\n"
+             "- Propose ideas or refine user's suggestions to meet the criteria.\n"
+             "- If an idea proposed by you or the user clearly meets all criteria and you believe it's a good final choice, respond ONLY with the exact phrase: 'IDEA FINALIZED: [Name of the Idea]'. Example: 'IDEA FINALIZED: Simple Wooden Spice Rack'. Do not add any other text before or after this phrase if you use it.\n"
+             "- If you need more information from the user to refine an idea, or if their current suggestion doesn't meet the criteria, ask clarifying questions. Guide them towards simpler, more accessible options.\n"
+             "- If you are stuck, the user's request is too vague for you to make progress towards a suitable idea, or they propose something clearly outside the 'universally available materials' constraint, and you need their direct input to clarify fundamental aspects, you should use the 'human_assistance' tool. Frame your request for the human clearly. For example: 'To ensure the idea is simple enough, could you tell me what kind of tools you are comfortable using?' or 'The idea of a custom electronic gadget is interesting, but finding parts globally is hard. Could we think of a non-electronic version, or what's the core function you want from it that we could achieve with simpler materials?'"
+             ),
+            MessagesPlaceholder(variable_name="messages"),
+        ]
+    )
+
+    # Bind tools that this node can use
+    # For brainstorming, human_assistance is key. Search might also be useful.
+    node_tools = [human_assistance]
+    if state.search_enabled and tavily_search_tool: # Check if tavily_search_tool was initialized
+        node_tools.append(tavily_search_tool)
+
+    llm_with_tools = model.bind_tools(node_tools)
+    chain = brainstorming_system_prompt_template | llm_with_tools
+
+    # Get the current messages from the state
+    current_messages = state.messages
+    # Log current messages for debugging
+    # print("Messages sent to brainstorming LLM:")
+    # for msg in current_messages:
+    #     print(f"  {msg.type}: {msg.content}")
+
+    response_message = await chain.ainvoke({"messages": current_messages}, config=config)
+    # print(f"Brainstorming LLM raw response: {response_message}")
+
+
+    updates = {"messages": [response_message]} # Add the AI's response to the history
+
+    # Check for the finalization signal in the AI's response content
+    if isinstance(response_message, AIMessage) and response_message.content:
+        if response_message.content.startswith("IDEA FINALIZED:"):
+            updates["brainstorming_complete"] = True
+            # Optionally, extract the idea name and store it if needed elsewhere in the state
+            # idea_name = response_message.content.replace("IDEA FINALIZED:", "").strip()
+            # updates["finalized_idea_name"] = idea_name # If you add this to GraphProcessingState
+            print(f"✅ Brainstorming complete! Idea: {response_message.content}")
+        elif response_message.tool_calls:
+            print(f"🛠️ Brainstorming node initiated tool call(s): {response_message.tool_calls}")
+        else:
+            print(f"💬 Brainstorming node continues discussion: {response_message.content}")
+
+
+    return updates
+
+async def planning_node(state: GraphProcessingState, config=None):
+    # Define the system prompt for planning
+    planning_prompt = "Based on the user's idea, create a detailed step-by-step plan to build the DIY product."
+
+    # Combine the planning prompt with any existing prompts
+    if state.prompt:
+        final_prompt = "\n".join([planning_prompt, state.prompt, ASSISTANT_SYSTEM_PROMPT_BASE])
     else:
-        logger.info("Idea is incomplete. Routing back to 'assistant_node'.")
-        return "assistant_node"
+        final_prompt = "\n".join([planning_prompt, ASSISTANT_SYSTEM_PROMPT_BASE])
 
-def guidance_routing(state: GraphProcessingState) -> str:
-    # Use logger.debug() for verbose debugging information
-    # This allows you to control its visibility via logging configuration
-    print("\n--- Guidance Routing Edge (Debug via print) ---") # Added a newline for clarity
+    # Create the prompt template
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", final_prompt),
+            MessagesPlaceholder(variable_name="messages"),
+        ]
+    )
 
-    # Log the entire state as a dictionary (Pydantic's .model_dump())
-    # This is very comprehensive. For large states, consider logging parts.
-    # logger.debug(f"Full State: {state.model_dump(mode='json')}") # mode='json' makes it JSON-serializable
-    # Or for a more Pythonic dict:
-    # print(f"Full State Dict: {state.model_dump()}")
+    # Bind tools if necessary
+    assistant_tools = []
+    if state.tools_enabled.get("download_website_text", True):
+        assistant_tools.append(download_website_text)
+    if search_enabled and state.tools_enabled.get("tavily_search_results_json", True):
+        assistant_tools.append(tavily_search_tool)
+    assistant_model = model.bind_tools(assistant_tools)
 
+    # Create the chain and invoke it
+    chain = prompt | assistant_model
+    response = await chain.ainvoke({"messages": state.messages}, config=config)
 
+    return {
+        "messages": response
+    }
+
+
+def guidance_routing(state: GraphProcessingState) -> str:
+
+    print("\n--- Guidance Routing Edge (Debug via print) ---") # Added a newline for clarity
     print(f"Prompt: {state.prompt}")
     # print(f"Message: {state.messages}")
     print(f"Tools Enabled: {state.tools_enabled}")
@@ -358,19 +329,21 @@ def guidance_routing(state: GraphProcessingState) -> str:
     print(f"Product Searching Complete: {state.product_searching_complete}")
     print(f"Purchasing Complete: {state.purchasing_complete}")
     print("--- End Guidance Node Debug ---") # Added for clarity
+    
     next_stage = state.next_stage
     if next_stage == "brainstorming":
-        return "assistant_node"
+        return "brainstorming_node"
+
     elif next_stage == "planning":
-        return "planning_node"
-    elif next_stage == "drawing":
-        return "tools"
-    elif next_stage == "product_searching":
-        return "assistant_node"
-    elif next_stage == "purchasing":
-        return "assistant_node"
+    #     return "planning_node"
+    # elif next_stage == "drawing":
+    #     return "drawing_node"
+    # elif next_stage == "product_searching":
+    #     return "product_searching"
+    # elif next_stage == "purchasing":
+    #     return "purchasing_node"
 
-    return END
+        return END
 
 
 
@@ -380,10 +353,11 @@ def define_workflow() -> CompiledStateGraph:
     workflow = StateGraph(GraphProcessingState)
 
     # Add nodes
-    workflow.add_node("assistant_node", assistant_node)
     workflow.add_node("tools", ToolNode(tools))
     workflow.add_node("planning_node", planning_node)
     workflow.add_node("guidance_node", guidance_node)
+    workflow.add_node("brainstorming_node", brainstorming_node)
+
 
     # workflow.add_node("chatbot", chatbot)
 
@@ -391,7 +365,8 @@ def define_workflow() -> CompiledStateGraph:
     workflow.add_edge("tools", "guidance_node")
     # workflow.add_edge("planning_node", "assistant_node")
     workflow.add_edge("planning_node", "guidance_node")
-    workflow.add_edge("assistant_node", "guidance_node")
+    workflow.add_edge("brainstorming_node", "guidance_node")
+
 
 
 
@@ -423,4 +398,88 @@ def define_workflow() -> CompiledStateGraph:
 
     return compiled_graph
 
-graph = define_workflow()
+graph = define_workflow()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# async def assistant_node(state: GraphProcessingState, config=None):
+#     print("\n--- Assistance Node (Debug via print) ---") # Added a newline for clarity
+
+
+#     print(f"Prompt: {state.prompt}")
+
+#     print(f"Tools Enabled: {state.tools_enabled}")
+#     print(f"Search Enabled: {state.search_enabled}")
+#     print(f"Next Stage: {state.next_stage}")
+
+
+#     # Log boolean completion flags
+#     print(f"Idea Complete: {state.idea_complete}")
+#     print(f"Brainstorming Complete: {state.brainstorming_complete}")
+#     print(f"Planning Complete: {state.planning_complete}")
+#     print(f"Drawing Complete: {state.drawing_complete}")
+#     print(f"Product Searching Complete: {state.product_searching_complete}")
+#     print(f"Purchasing Complete: {state.purchasing_complete}")
+#     print("--- End Guidance Node Debug ---") # Added for clarity
+#     print(f"\nMessage: {state.messages}")
+#     assistant_tools = []
+#     if state.tools_enabled.get("download_website_text", True):
+#         assistant_tools.append(download_website_text)
+#     if search_enabled and state.tools_enabled.get("tavily_search_results_json", True):
+#         assistant_tools.append(tavily_search_tool)
+#     assistant_model = model.bind_tools(assistant_tools)
+#     if state.prompt:
+#         final_prompt = "\n".join([state.prompt, ASSISTANT_SYSTEM_PROMPT_BASE])
+#     else:
+#         final_prompt = ASSISTANT_SYSTEM_PROMPT_BASE
+
+#     prompt = ChatPromptTemplate.from_messages(
+#         [
+#             ("system", final_prompt),
+#             MessagesPlaceholder(variable_name="messages"),
+#         ]
+#     )
+#     chain = prompt | assistant_model
+#     response = await chain.ainvoke({"messages": state.messages}, config=config)
+
+#     for msg in response:
+#         if isinstance(msg, HumanMessage):
+#             print("Human:", msg.content)
+#         elif isinstance(msg, AIMessage):
+#             if isinstance(msg.content, list):
+#                 ai_texts = [part.get("text", "") for part in msg.content if isinstance(part, dict)]
+#                 print("AI:", " ".join(ai_texts))
+#             else:
+#                 print("AI:", msg.content)
+
+#     idea_complete = evaluate_idea_completion(response)
+
+#     return {
+#         "messages": response,
+#         "idea_complete": idea_complete
+#     }
+
+#     # message = llm_with_tools.invoke(state["messages"])
+#     # Because we will be interrupting during tool execution,
+#     # we disable parallel tool calling to avoid repeating any
+#     # tool invocations when we resume.
+#     assert len(response.tool_calls) <= 1
+#     idea_complete = evaluate_idea_completion(response)
+
+#     return {
+#         "messages": response,
+#         "idea_complete": idea_complete
+#     }