first valid commit

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,14 @@
+---
+title: DIY Assistant
+emoji: 💬
+colorFrom: yellow
+colorTo: purple
+sdk: gradio
+sdk_version: 5.0.1
+app_file: app.py
+pinned: false
+license: mit
+short_description: DIY assistant
+---
+
+An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).

app.py

@@ -0,0 +1,855 @@
+import os
+import logging
+import logging.config
+from typing import Any
+from uuid import uuid4, UUID
+import json
+import sys
+
+import gradio as gr
+from dotenv import load_dotenv
+from langchain_core.messages import SystemMessage, HumanMessage, AIMessage, ToolMessage
+from langgraph.types import RunnableConfig
+from pydantic import BaseModel
+from pathlib import Path
+
+
+import subprocess
+
+# def update_repo():
+#     try:
+#         subprocess.run(["git", "fetch", "origin"], check=True)
+#         subprocess.run(["git", "reset", "--hard", "origin/main"], check=True)
+#         subprocess.run([sys.executable, "-m", "pip", "install", "-r", "requirements.txt"], check=True)
+#         subprocess.run([sys.executable, "app.py"], check=True)
+#     except Exception as e:
+#         print(f"Git update failed: {e}")
+
+# update_repo()
+
+load_dotenv()
+
+
+
+# There are tools set here dependent on environment variables
+from graph import graph, weak_model, search_enabled # noqa
+
+FOLLOWUP_QUESTION_NUMBER = 3
+TRIM_MESSAGE_LENGTH = 16  # Includes tool messages
+USER_INPUT_MAX_LENGTH = 10000  # Characters
+
+# We need the same secret for data persistance
+# If you store sensitive data, you should store your secret in .env
+BROWSER_STORAGE_SECRET = "itsnosecret"
+
+with open('logging-config.json', 'r') as fh:
+    config = json.load(fh)
+logging.config.dictConfig(config)
+logger = logging.getLogger(__name__)
+
+def load_initial_greeting(filepath="greeting_prompt.txt") -> str:
+    """
+    Loads the initial greeting message from a specified text file.
+    """
+    try:
+        with open(filepath, "r", encoding="utf-8") as f:
+            return f.read().strip()
+    except FileNotFoundError:
+        # Use a logger if you have one configured, otherwise print
+        # logger.warning(f"Warning: Prompt file '{filepath}' not found.")
+        print(f"Warning: Prompt file '{filepath}' not found. Using default.")
+        return "Welcome to the application! (Default Greeting)"
+
+async def chat_fn(user_input: str, history: dict, input_graph_state: dict, uuid: UUID, prompt: str, search_enabled: bool, download_website_text_enabled: bool):
+    """
+    Args:
+        user_input (str): The user's input message
+        history (dict): The history of the conversation in gradio
+        input_graph_state (dict): The current state of the graph. This includes tool call history
+        uuid (UUID): The unique identifier for the current conversation. This can be used in conjunction with langgraph or for memory
+        prompt (str): The system prompt
+    Yields:
+        str: The output message
+        dict|Any: The final state of the graph
+        bool|Any: Whether to trigger follow up questions
+
+        We do not use gradio history in the graph since we want the ToolMessage in the history
+        ordered properly. GraphProcessingState.messages is used as history instead
+    """
+    try:
+        logger.info(f"Prompt: {prompt}")
+        input_graph_state["tools_enabled"] = {
+            "download_website_text": download_website_text_enabled,
+            "tavily_search_results_json": search_enabled,
+        }
+        if prompt:
+            input_graph_state["prompt"] = prompt
+
+        if input_graph_state.get("awaiting_human_input"):
+            input_graph_state["messages"].append(
+                ToolMessage(
+                    tool_call_id=input_graph_state.pop("human_assistance_tool_id"),
+                    content=user_input
+                )
+            )
+            input_graph_state["awaiting_human_input"] = False
+        else:
+            # New user message
+            if "messages" not in input_graph_state:
+                input_graph_state["messages"] = []
+            input_graph_state["messages"].append(
+                HumanMessage(user_input[:USER_INPUT_MAX_LENGTH])
+            )
+            input_graph_state["messages"] = input_graph_state["messages"][-TRIM_MESSAGE_LENGTH:]
+
+        config = RunnableConfig(
+            recursion_limit=20,
+            run_name="user_chat",
+            configurable={"thread_id": uuid}
+        )
+
+        output: str = ""
+        final_state: dict | Any = {}
+        waiting_output_seq: list[str] = []
+
+        async for stream_mode, chunk in graph.astream(
+                    input_graph_state,
+                    config=config,
+                    stream_mode=["values", "messages"],
+                ):
+            if stream_mode == "values":
+                final_state = chunk
+                last_message = chunk["messages"][-1]
+                if hasattr(last_message, "tool_calls"):
+                    for msg_tool_call in last_message.tool_calls:
+                        tool_name: str = msg_tool_call['name']
+
+                        if tool_name == "tavily_search_results_json":
+                            query = msg_tool_call['args']['query']
+                            waiting_output_seq.append(f"Searching for '{query}'...")
+                            yield "\n".join(waiting_output_seq), gr.skip(), gr.skip()
+
+                        # download_website_text is the name of the function defined in graph.py
+                        elif tool_name == "download_website_text":
+                            url = msg_tool_call['args']['url']
+                            waiting_output_seq.append(f"Downloading text from '{url}'...")
+                            yield "\n".join(waiting_output_seq), gr.skip(), gr.skip()
+
+                        elif tool_name == "human_assistance":
+                            query = msg_tool_call["args"]["query"]
+                            waiting_output_seq.append(f"🤖: {query}")
+
+                            # Save state to resume after user provides input
+                            input_graph_state["awaiting_human_input"] = True
+                            input_graph_state["human_assistance_tool_id"] = msg_tool_call["id"]
+
+                            # Indicate that human input is needed
+                            yield "\n".join(waiting_output_seq), input_graph_state, gr.skip(), True
+                            return  # Pause execution, resume in next call
+
+                        else:
+                            waiting_output_seq.append(f"Running {tool_name}...")
+                            yield "\n".join(waiting_output_seq), gr.skip(), gr.skip()
+
+            elif stream_mode == "messages":
+                msg, metadata = chunk
+                # print("output: ", msg, metadata)
+                # assistant_node is the name we defined in the langgraph graph
+                if metadata.get('langgraph_node') == "assistant_node": # Use .get for safety
+                    current_chunk_text = ""
+                    if isinstance(msg.content, str):
+                        current_chunk_text = msg.content
+                    elif isinstance(msg.content, list):
+                        for block in msg.content:
+                            if isinstance(block, dict) and block.get("type") == "text":
+                                current_chunk_text += block.get("text", "")
+                            elif isinstance(block, str): # Fallback if content is list of strings
+                                current_chunk_text += block
+
+                    
+                    if current_chunk_text: # Only add and yield if there's actually text
+                        output += current_chunk_text
+                        yield output, gr.skip(), gr.skip()
+
+        # Trigger for asking follow up questions
+        # + store the graph state for next iteration
+        # yield output, dict(final_state), gr.skip()
+        yield output + " ", dict(final_state), True
+    except Exception:
+        logger.exception("Exception occurred")
+        user_error_message = "There was an error processing your request. Please try again."
+        yield user_error_message, gr.skip(), False
+
+def clear():
+    return dict(), uuid4()
+
+class FollowupQuestions(BaseModel):
+    """Model for langchain to use for structured output for followup questions"""
+    questions: list[str]
+
+async def populate_followup_questions(end_of_chat_response: bool, messages: dict[str, str], uuid: UUID):
+    """
+    This function gets called a lot due to the asynchronous nature of streaming
+
+    Only populate followup questions if streaming has completed and the message is coming from the assistant
+    """
+    if not end_of_chat_response or not messages or messages[-1]["role"] != "assistant":
+        return *[gr.skip() for _ in range(FOLLOWUP_QUESTION_NUMBER)], False
+    config = RunnableConfig(
+        run_name="populate_followup_questions",
+        configurable={"thread_id": uuid}
+    )
+    weak_model_with_config = weak_model.with_config(config)
+    follow_up_questions = await weak_model_with_config.with_structured_output(FollowupQuestions).ainvoke([
+        ("system", f"suggest {FOLLOWUP_QUESTION_NUMBER} followup questions for the user to ask the assistant. Refrain from asking personal questions."),
+        *messages,
+    ])
+    if len(follow_up_questions.questions) != FOLLOWUP_QUESTION_NUMBER:
+        raise ValueError("Invalid value of followup questions")
+    buttons = []
+    for i in range(FOLLOWUP_QUESTION_NUMBER):
+        buttons.append(
+            gr.Button(follow_up_questions.questions[i], visible=True, elem_classes="chat-tab"),
+        )
+    return *buttons, False
+
+async def summarize_chat(end_of_chat_response: bool, messages: dict, sidebar_summaries: dict, uuid: UUID):
+    """Summarize chat for tab names"""
+    # print("\n------------------------")
+    # print("not end_of_chat_response", not end_of_chat_response)
+    # print("not messages", not messages)
+    # if messages:
+    #     print("messages[-1][role] != assistant", messages[-1]["role"] != "assistant")
+    # print("isinstance(sidebar_summaries, type(lambda x: x))", isinstance(sidebar_summaries, type(lambda x: x)))
+    # print("uuid in sidebar_summaries", uuid in sidebar_summaries)
+    should_return = (
+        not end_of_chat_response or
+        not messages or
+        messages[-1]["role"] != "assistant" or
+        # This is a bug with gradio
+        isinstance(sidebar_summaries, type(lambda x: x)) or
+        # Already created summary
+        uuid in sidebar_summaries
+    )
+    if should_return:
+        return gr.skip(), gr.skip()
+
+    filtered_messages = []
+    for msg in messages:
+        if isinstance(msg, dict) and msg.get("content") and msg["content"].strip():
+            filtered_messages.append(msg)
+    
+    # If we don't have any valid messages after filtering, provide a default summary
+    if not filtered_messages:
+        if uuid not in sidebar_summaries:
+            sidebar_summaries[uuid] = "Chat History"
+        return sidebar_summaries, False
+
+
+    config = RunnableConfig(
+        run_name="summarize_chat",
+        configurable={"thread_id": uuid}
+    )
+    try:
+        weak_model_with_config = weak_model.with_config(config)
+        summary_response = await weak_model_with_config.ainvoke([
+            ("system", "summarize this chat in 7 tokens or less. Refrain from using periods"),
+            *filtered_messages,
+        ])
+        
+        if uuid not in sidebar_summaries:
+            sidebar_summaries[uuid] = summary_response.content
+    except Exception as e:
+        logger.error(f"Error summarizing chat: {e}")
+        # Provide a fallback summary if an error occurs
+        if uuid not in sidebar_summaries:
+            sidebar_summaries[uuid] = "Previous Chat"
+    
+    return sidebar_summaries, False
+
+async def new_tab(uuid, gradio_graph, messages, tabs, prompt, sidebar_summaries):
+    new_uuid = uuid4()
+    new_graph = {}
+    if uuid not in sidebar_summaries:
+        sidebar_summaries, _ = await summarize_chat(True, messages, sidebar_summaries, uuid)
+    tabs[uuid] = {
+        "graph": gradio_graph,
+        "messages": messages,
+        "prompt": prompt,
+    }
+    suggestion_buttons = []
+    for _ in range(FOLLOWUP_QUESTION_NUMBER):
+        suggestion_buttons.append(gr.Button(visible=False))
+    new_messages = {}
+
+    # --- MODIFICATION FOR GREETING IN EVERY NEW CHAT ---
+    greeting_text = load_initial_greeting() # Get the greeting
+    # `gr.Chatbot` expects a list of tuples or list of dicts.
+    # For `type="messages"`, it's list of dicts: [{"role": "assistant", "content": "Hello"}]
+    # Or list of tuples: [(None, "Hello")]
+    # Let's assume your chatbot is configured for list of tuples (None, bot_message) for initial messages
+    new_chat_messages_for_display = [{"role": "assistant", "content": greeting_text}]
+    # If your chat_interface.chatbot_value expects list of dicts:
+    # new_messages_history = [{"role": "assistant", "content": greeting_text}]
+    # --- END MODIFICATION ---
+
+    new_prompt = "You are a helpful assistant."
+    return new_uuid, new_graph, new_chat_messages_for_display, tabs, new_prompt, sidebar_summaries, *suggestion_buttons
+
+def switch_tab(selected_uuid, tabs, gradio_graph, uuid, messages, prompt):
+    # I don't know of another way to lookup uuid other than
+    # by the button value
+
+    # Save current state
+    if messages:
+        tabs[uuid] = {
+            "graph": gradio_graph,
+            "messages": messages,
+            "prompt": prompt
+        }
+
+    if selected_uuid not in tabs:
+        logger.error(f"Could not find the selected tab in offloaded_tabs_data_storage {selected_uuid}")
+        return gr.skip(), gr.skip(), gr.skip(), gr.skip()
+    selected_tab_state = tabs[selected_uuid]
+    selected_graph = selected_tab_state["graph"]
+    selected_messages = selected_tab_state["messages"]
+    selected_prompt = selected_tab_state.get("prompt", "")
+    suggestion_buttons = []
+    for _ in range(FOLLOWUP_QUESTION_NUMBER):
+        suggestion_buttons.append(gr.Button(visible=False))
+    return selected_graph, selected_uuid, selected_messages, tabs, selected_prompt, *suggestion_buttons
+
+def delete_tab(current_chat_uuid, selected_uuid, sidebar_summaries, tabs):
+    output_messages = gr.skip()
+    if current_chat_uuid == selected_uuid:
+        output_messages = dict()
+    if selected_uuid in tabs:
+        del tabs[selected_uuid]
+    if selected_uuid in sidebar_summaries:
+        del sidebar_summaries[selected_uuid]
+    return sidebar_summaries, tabs, output_messages
+
+def submit_edit_tab(selected_uuid, sidebar_summaries, text):
+    sidebar_summaries[selected_uuid] = text
+    return sidebar_summaries, ""
+
+def load_mesh(mesh_file_name):
+            return mesh_file_name
+
+def display_initial_greeting(is_new_user_state_value: bool):
+    """
+    Determines if a greeting should be displayed and returns the UI updates.
+    It also returns the new state for 'is_new_user_for_greeting'.
+    """
+    if is_new_user_state_value:
+        greeting_message_text = load_initial_greeting()
+        # For a chatbot, the history is a list of tuples: [(user_msg, bot_msg)]
+        # For an initial message from the bot, user_msg is None.
+        initial_chat_history = [(None, greeting_message_text)]
+        updated_is_new_user_flag = False # Greeting shown, so set to False
+        return initial_chat_history, updated_is_new_user_flag
+    else:
+        # Not a new user (or already greeted), so no initial message in chat history
+        # and the flag remains False.
+        return [], False
+
+def get_sorted_3d_model_examples():
+    examples_dir = Path("./generated_3d_models")
+    if not examples_dir.exists():
+        return []
+
+    # Get all 3D model files with desired extensions
+    model_files = [
+        file for file in examples_dir.glob("*")
+        if file.suffix.lower() in {".obj", ".glb", ".gltf"}
+    ]
+
+    # Sort files by creation time (latest first)
+    sorted_files = sorted(
+        model_files,
+        key=lambda x: x.stat().st_ctime,
+        reverse=True
+    )
+
+    # Convert to format [[path1], [path2], ...]
+    return [[str(file)] for file in sorted_files]
+
+
+CSS = """
+footer {visibility: hidden}
+.followup-question-button {font-size: 12px }
+.chat-tab {
+    font-size: 12px;
+    padding-inline: 0;
+}
+.chat-tab.active {
+    background-color: #654343;
+}
+#new-chat-button { background-color: #0f0f11; color: white; }
+
+.tab-button-control {
+    min-width: 0;
+    padding-left: 0;
+    padding-right: 0;
+}
+
+.sidebar-collapsed {
+    display: none !important;
+}
+
+.wrap.sidebar-parent {
+    min-height: 2400px !important;
+    height: 2400px !important;
+}
+
+#main-app {
+    height: 4600px;  /* or 800px, or 100% */
+    overflow-y: auto;  /* optional if you want it scrollable */\
+    padding-top:2000px;
+}
+
+"""
+
+# We set the ChatInterface textbox id to chat-textbox for this to work
+TRIGGER_CHATINTERFACE_BUTTON = """
+function triggerChatButtonClick() {
+
+  // Find the div with id "chat-textbox"
+  const chatTextbox = document.getElementById("chat-textbox");
+
+  if (!chatTextbox) {
+    console.error("Error: Could not find element with id 'chat-textbox'");
+    return;
+  }
+
+  // Find the button that is a descendant of the div
+  const button = chatTextbox.querySelector("button");
+
+  if (!button) {
+    console.error("Error: No button found inside the chat-textbox element");
+    return;
+  }
+
+  // Trigger the click event
+  button.click();
+}"""
+
+
+
+TOGGLE_SIDEBAR_JS = """
+function toggleSidebarVisibility() {
+    console.log("Called the side bar funnction");
+    const sidebar = document.querySelector(".sidebar svelte-7y53u7 open");
+    if (!sidebar) {
+        console.error("Error: Could not find the sidebar element");
+        return;
+    }
+    sidebar.classList.toggle("sidebar-collapsed");
+}
+"""
+
+if __name__ == "__main__":
+    logger.info("Starting the interface")
+    with gr.Blocks(title="DIYO is here", fill_height=True, css=CSS, elem_id="main-app") as demo:
+        is_new_user_for_greeting = gr.State(True)
+        chatbot_message_storage = gr.State([])
+        current_prompt_state = gr.BrowserState(
+            storage_key="current_prompt_state",
+            secret=BROWSER_STORAGE_SECRET,
+        )
+        current_uuid_state = gr.BrowserState(
+            uuid4,
+            storage_key="current_uuid_state",
+            secret=BROWSER_STORAGE_SECRET,
+        )
+        current_langgraph_state = gr.BrowserState(
+            dict(),
+            storage_key="current_langgraph_state",
+            secret=BROWSER_STORAGE_SECRET,
+        )
+        end_of_assistant_response_state = gr.State(
+            bool(),
+        )
+        # [uuid] -> summary of chat
+        sidebar_names_state = gr.BrowserState(
+            dict(),
+            storage_key="sidebar_names_state",
+            secret=BROWSER_STORAGE_SECRET,
+        )
+        # [uuid] -> {"graph": gradio_graph, "messages": messages}
+        offloaded_tabs_data_storage = gr.BrowserState(
+            dict(),
+            storage_key="offloaded_tabs_data_storage",
+            secret=BROWSER_STORAGE_SECRET,
+        )
+
+        chatbot_message_storage = gr.BrowserState(
+            [],
+            storage_key="chatbot_message_storage",
+            secret=BROWSER_STORAGE_SECRET,
+        )
+        
+        with gr.Row(elem_classes="header-margin"):
+            # Add the decorated header with ASCII art
+            gr.Markdown("""
+            <div style="display: flex; align-items: center; justify-content: center; text-align: center; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 15px; margin-bottom: 20px; color: white; box-shadow: 0 4px 15px rgba(0,0,0,0.2);">
+            
+                ╔══════════════════════════════════════════════════════════════════════════════════════════════╗
+                ║                                                                                              ║
+                ║      █████╗  ██████╗ ███████╗███╗   ██╗████████╗         ██████╗ ██╗██╗   ██╗ ██████╗        ║                  
+                ║     ██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝         ██╔══██╗██║╚██╗ ██╔╝██╔═══██╗       ║             
+                ║     ███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║            ██║  ██║██║ ╚████╔╝ ██║   ██║       ║           
+                ║     ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║            ██║  ██║██║  ╚██╔╝  ██║   ██║       ║                     
+                ║     ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║            ██████╔╝██║   ██║   ╚██████╔╝       ║                      
+                ║     ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝            ╚═════╝ ╚═╝   ╚═╝    ╚═════╝        ║                    
+                ║                                                                                              ║                    
+                ╚══════════════════════════════════════════════════════════════════════════════════════════════╝
+
+                                    Let's build things, break boundaries with the help of AI!
+            </div>
+            """)
+
+        with gr.Row():
+            prompt_textbox = gr.Textbox(show_label=False, interactive=True)
+        
+        with gr.Row():
+            checkbox_search_enabled = gr.Checkbox(
+                value=True,
+                label="Enable search",
+                show_label=True,
+                visible=search_enabled,
+                scale=1,
+            )
+            checkbox_download_website_text = gr.Checkbox(
+                value=True,
+                show_label=True,
+                label="Enable downloading text from urls",
+                scale=1,
+            )
+        with gr.Row():
+            with gr.Column(scale=2):
+                model_3d_output = gr.Model3D(
+                    clear_color=[0.0, 0.0, 0.0, 0.0],
+                    label="3D Model",
+                    height=400 # Adjust height to align better with chatbot
+                )
+            with gr.Column(scale=1):
+                # Input for the 3D model
+                # Using UploadButton is often clearer for users than a clickable Model3D input
+                model_3d_upload_button = gr.UploadButton(
+                    "Upload 3D Model (.obj, .glb, .gltf)",
+                    file_types=[".obj", ".glb", ".gltf"],
+                    # scale=0 # make it take less space if needed
+                )
+                model_3d_upload_button.upload(
+                    fn=load_mesh,
+                    inputs=model_3d_upload_button,
+                    outputs=model_3d_output
+                )
+                gr.Examples(
+                    label="Example 3D Models",
+                    examples=get_sorted_3d_model_examples(),
+                    inputs=model_3d_upload_button, # Dummy input for examples to load into Model3D
+                    outputs=model_3d_output,
+                    fn=load_mesh,
+                    cache_examples=True # Caching might be useful
+                )
+        with gr.Row(): 
+            multimodal = False
+            textbox_component = (
+                gr.MultimodalTextbox if multimodal else gr.Textbox
+            )    
+        
+            textbox = textbox_component(
+                    show_label=False,
+                    label="Message",
+                    placeholder="Type a message...",
+                    scale=1,
+                    autofocus=True,
+                    submit_btn=True,
+                    stop_btn=True,
+                    elem_id="chat-textbox",
+                    lines=1,
+                )
+            chatbot = gr.Chatbot(
+                    type="messages",
+                    scale=0,
+                    show_copy_button=True,
+                    height=400,
+                    editable="all",
+                    elem_classes="main-chatbox"
+                )
+            with gr.Row():
+                    followup_question_buttons = []
+                    for i in range(FOLLOWUP_QUESTION_NUMBER):
+                        btn = gr.Button(f"Button {i+1}", visible=False)
+                        followup_question_buttons.append(btn)
+        
+
+            
+        tab_edit_uuid_state = gr.State(
+            str()
+        )
+        prompt_textbox.change(lambda prompt: prompt, inputs=[prompt_textbox], outputs=[current_prompt_state])
+        with gr.Sidebar() as sidebar:
+            @gr.render(inputs=[tab_edit_uuid_state, end_of_assistant_response_state, sidebar_names_state, current_uuid_state, chatbot, offloaded_tabs_data_storage])
+            def render_chats(tab_uuid_edit, end_of_chat_response, sidebar_summaries, active_uuid, messages, tabs):
+                current_tab_button_text = ""
+                if active_uuid not in sidebar_summaries:
+                    current_tab_button_text = "Current Chat"
+                elif active_uuid not in tabs:
+                    current_tab_button_text = sidebar_summaries[active_uuid]
+                if current_tab_button_text:
+                    unique_id = f"current-tab-{active_uuid}-{uuid4()}"
+                    gr.Button(
+                        current_tab_button_text, 
+                        elem_classes=["chat-tab", "active"], 
+                        elem_id=unique_id # Add unique elem_id
+                    )
+                for chat_uuid, tab in reversed(tabs.items()):
+                    elem_classes = ["chat-tab"]
+                    if chat_uuid == active_uuid:
+                        elem_classes.append("active")
+                    button_uuid_state = gr.State(chat_uuid)
+                    with gr.Row():
+                        clear_tab_button = gr.Button(
+                            "🗑",
+                            scale=0,
+                            elem_classes=["tab-button-control"],
+                            elem_id=f"delete-btn-{chat_uuid}-{uuid4()}"  # Add unique ID
+                        )
+                        clear_tab_button.click(
+                            fn=delete_tab,
+                            inputs=[
+                                current_uuid_state,
+                                button_uuid_state,
+                                sidebar_names_state,
+                                offloaded_tabs_data_storage
+                            ],
+                            outputs=[
+                                sidebar_names_state,
+                                offloaded_tabs_data_storage,
+                                chat_interface.chatbot_value
+                            ]
+                        )
+                        chat_button_text = sidebar_summaries.get(chat_uuid)
+                        if not chat_button_text:
+                            chat_button_text = str(chat_uuid)
+                        if chat_uuid != tab_uuid_edit:
+                            set_edit_tab_button = gr.Button(
+                                "✎",
+                                scale=0,
+                                elem_classes=["tab-button-control"],
+                                elem_id=f"edit-btn-{chat_uuid}-{uuid4()}"  # Add unique ID
+                            )
+                            set_edit_tab_button.click(
+                                fn=lambda x: x,
+                                inputs=[button_uuid_state],
+                                outputs=[tab_edit_uuid_state]
+                            )
+                            chat_tab_button = gr.Button(
+                                chat_button_text,
+                                elem_id=f"chat-{chat_uuid}-{uuid4()}",  # Add truly unique ID
+                                elem_classes=elem_classes,
+                                scale=2
+                            )
+                            chat_tab_button.click(
+                                fn=switch_tab,
+                                inputs=[
+                                    button_uuid_state,
+                                    offloaded_tabs_data_storage,
+                                    current_langgraph_state,
+                                    current_uuid_state,
+                                    chatbot,
+                                    prompt_textbox
+                                ],
+                                outputs=[
+                                    current_langgraph_state,
+                                    current_uuid_state,
+                                    chat_interface.chatbot_value,
+                                    offloaded_tabs_data_storage,
+                                    prompt_textbox,
+                                    *followup_question_buttons
+                                ]
+                            )
+                        else:
+                            chat_tab_text = gr.Textbox(
+                                chat_button_text,
+                                scale=2,
+                                interactive=True,
+                                show_label=False,
+                                elem_id=f"edit-text-{chat_uuid}-{uuid4()}"  # Add unique ID
+                            )
+                            chat_tab_text.submit(
+                                fn=submit_edit_tab,
+                                inputs=[
+                                    button_uuid_state,
+                                    sidebar_names_state,
+                                    chat_tab_text
+                                ],
+                                outputs=[
+                                    sidebar_names_state,
+                                    tab_edit_uuid_state
+                                ]
+                            )
+                    # )
+                # return chat_tabs, sidebar_summaries
+            new_chat_button = gr.Button("New Chat", elem_id="new-chat-button")
+        chatbot.clear(fn=clear, outputs=[current_langgraph_state, current_uuid_state])
+        
+        chat_interface = gr.ChatInterface(
+            chatbot=chatbot,
+            fn=chat_fn,
+            additional_inputs=[
+                current_langgraph_state,
+                current_uuid_state,
+                prompt_textbox,
+                checkbox_search_enabled,
+                checkbox_download_website_text,
+            ],
+            additional_outputs=[
+                current_langgraph_state,
+                end_of_assistant_response_state
+            ],
+            type="messages",
+            multimodal=multimodal,
+            textbox=textbox,
+        )
+
+        new_chat_button.click(
+            new_tab,
+            inputs=[
+                current_uuid_state,
+                current_langgraph_state,
+                chatbot,
+                offloaded_tabs_data_storage,
+                prompt_textbox,
+                sidebar_names_state,
+            ],
+            outputs=[
+                current_uuid_state,
+                current_langgraph_state,
+                chat_interface.chatbot_value,
+                offloaded_tabs_data_storage,
+                prompt_textbox,
+                sidebar_names_state,
+                *followup_question_buttons,
+            ]
+        )
+
+
+        def click_followup_button(btn):
+            buttons = [gr.Button(visible=False) for _ in range(len(followup_question_buttons))]
+            return btn, *buttons
+
+        
+        for btn in followup_question_buttons:
+            btn.click(
+                fn=click_followup_button,
+                inputs=[btn],
+                outputs=[
+                    chat_interface.textbox,
+                    *followup_question_buttons
+                ]
+            ).success(lambda: None, js=TRIGGER_CHATINTERFACE_BUTTON)
+
+        chatbot.change(
+            fn=populate_followup_questions,
+            inputs=[
+                end_of_assistant_response_state,
+                chatbot,
+                current_uuid_state
+            ],
+            outputs=[
+                *followup_question_buttons,
+                end_of_assistant_response_state
+            ],
+            trigger_mode="multiple"
+        )
+        chatbot.change(
+            fn=summarize_chat,
+            inputs=[
+                end_of_assistant_response_state,
+                chatbot,
+                sidebar_names_state,
+                current_uuid_state
+            ],
+            outputs=[
+                sidebar_names_state,
+                end_of_assistant_response_state
+            ],
+            trigger_mode="multiple"
+        )
+        chatbot.change(
+            fn=lambda x: x,
+            inputs=[chatbot],
+            outputs=[chatbot_message_storage],
+            trigger_mode="always_last"
+        )
+
+        @demo.load( # Or demo.load
+            inputs=[
+                is_new_user_for_greeting,
+                chatbot_message_storage # Pass the current stored messages
+            ],
+            outputs=[
+                chatbot_message_storage,    # Update the stored messages with the greeting
+                is_new_user_for_greeting    # Update the flag
+            ]
+        )
+        def handle_initial_greeting_load(current_is_new_user_flag: bool, existing_chat_history: list):
+            """
+            This function is called by the @app.load decorator above.
+            It decides whether to add a greeting to the chat history.
+            """
+            # You can either put the logic directly here, or call the globally defined one.
+            # Option 1: Call the globally defined function (cleaner if it's complex)
+            # Make sure 'display_initial_greeting_on_load' is defined globally in your app.py
+            # For this example, I'm assuming 'display_initial_greeting_on_load' is the one we defined earlier:
+            # def display_initial_greeting_on_load(current_is_new_user_flag: bool, existing_chat_history: list):
+            #     if current_is_new_user_flag:
+            #         greeting_message_text = load_initial_greeting() # from graph.py
+            #         greeting_entry = (None, greeting_message_text)
+            #         if not isinstance(existing_chat_history, list): existing_chat_history = []
+            #         updated_chat_history = [greeting_entry] + existing_chat_history
+            #         updated_is_new_user_flag = False
+            #         logger.info("Greeting added for new user.")
+            #         return updated_chat_history, updated_is_new_user_flag
+            #     else:
+            #         logger.info("Not a new user or already greeted, no greeting added.")
+            #         return existing_chat_history, False
+            #
+            # return display_initial_greeting_on_load(current_is_new_user_flag, existing_chat_history)
+
+            # Option 2: Put logic directly here (if simple enough)
+            if current_is_new_user_flag:
+                greeting_message_text = load_initial_greeting() # Make sure load_initial_greeting is imported
+                greeting_entry = {"role": "assistant", "content": greeting_message_text}
+                # Ensure existing_chat_history is a list before concatenation
+                if not isinstance(existing_chat_history, list):
+                    existing_chat_history = []
+                updated_chat_history = [greeting_entry] + existing_chat_history
+                updated_is_new_user_flag = False
+                logger.info("Greeting added for new user via handle_initial_greeting_load.")
+                return updated_chat_history, updated_is_new_user_flag
+            else:
+                logger.info("Not a new user or already greeted (handle_initial_greeting_load path).")
+                return existing_chat_history, False
+
+        @demo.load(inputs=[chatbot_message_storage], outputs=[chat_interface.chatbot_value])
+        def load_messages(messages):
+            return messages
+
+        @demo.load(inputs=[current_prompt_state], outputs=[prompt_textbox])
+        def load_prompt(current_prompt):
+            return current_prompt
+
+    
+    demo.launch(server_name="127.0.0.1", server_port=8080, share=True)
+
+    # demo.launch(server_name="0.0.0.0", server_port=7860, share=True)
+
+
+
+

app.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+echo "Fetching latest code from origin/main..."
+git fetch origin
+git reset --hard origin/main
+
+echo "Starting the app..."
+python app.py  # or whatever your main entry point is trying to edit this foi just because

brainstorm_test.txt

@@ -0,0 +1,165 @@
+system_prompt: |-
+  You are a creative and helpful AI assistant acting as a **DIY Project Brainstorming Facilitator**. Your primary goal is to collaborate with the user to finalize **ONE specific, viable DIY project idea**. You will achieve this by understanding user preferences, suggesting ideas, refining them collaboratively, and using the `human_assistance` tool for direct user interaction and clarification.
+
+  f"CURRENT PROJECT STATUS:\n{status_summary}\n\n"
+  f"Based on the status, the most logical next stage appears to be: **'{proposed_next_stage}'**.\n\n"
+  
+just trying to run some code and and
+
+  **Critical Criteria for the Final DIY Project Idea (MUST be met):**
+  1.  **Buildable:** Achievable by an average person with basic DIY skills.
+  2.  **Common Materials/Tools:** Uses only materials (e.g., wood, screws, glue, paint, fabric, cardboard) and basic hand tools (e.g., screwdrivers, hammers, saws, drills) commonly available in general hardware stores, craft stores, or supermarkets worldwide.
+  3.  **Avoid Specializations:** Explicitly AVOID projects requiring specialized electronic components, 3D printing, specific brand items not universally available, or complex machinery.
+  4.  **Tangible Product:** The final result must be a physical, tangible item.
+
+  **Your Process for Each Brainstorming Interaction Cycle:**
+
+  1.  **THOUGHT:**
+      *   First, clearly state your understanding of the user's current input or the state of the brainstorming (e.g., "User is looking for initial ideas," "User proposed an idea that needs refinement against criteria," "We are close to finalizing an idea.").
+      *   Outline your plan for this interaction turn. This usually involves:
+          *   Engaging with the user's latest message.
+          *   Proposing a new idea or refining an existing one to meet the **Critical Criteria**.
+          *   Identifying if a question to the user is needed.
+      *   **Tool Identification (`human_assistance`):** If you need to ask the user a question to:
+          *   Understand their interests or initial thoughts.
+          *   Clarify their preferences or skill level (gently).
+          *   Get feedback on a proposed idea.
+          *   Refine an idea to meet criteria.
+          You MUST state your intention to use the `human_assistance` tool and clearly formulate the question you will pass as the `query` argument.
+      *   **Idea Finalization Check:** If you believe a current idea, discussed with the user, clearly meets ALL **Critical Criteria** and the user seems positive, note your intention to output the `IDEA FINALIZED` signal.
+
+  2.  **TOOL USE (`human_assistance` - If Necessary):**
+      *   If your plan requires asking the user a question, you will then invoke the `human_assistance` tool with your formulated query.
+      *   (Agent Builder Note: The LLM will output a tool call here. The system executes it.)
+
+  3.  **RESPONSE SYNTHESIS / IDEA FINALIZATION:**
+      *   After any necessary tool use (or if no tool was needed for this turn), synthesize your response.
+      *   **If an idea is finalized:** When you determine that a specific project idea meets ALL **Critical Criteria** and the user has positively engaged with it, your response for this turn MUST BE *ONLY* 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. This signals the end of brainstorming.
+      *   **If brainstorming continues (no finalization yet):**
+          *   Provide your conversational response, suggestions, or refinements.
+          *   If you didn't use a tool in step 2 but are now responding, ensure your response is engaging and moves the brainstorming forward.
+          *   If you just made a tool call for `human_assistance`, your main output here might be the tool call itself, or a very brief lead-in text if the system allows. Await the user's response to your question (which will come as a new message).
+
+  **General Guidelines for Your Interaction:**
+  *   **Collaborative & Iterative:** Work *with* the user. It's a conversation.
+  *   **Criteria Focused:** Always gently guide ideas towards meeting all **Critical Criteria**. If a user's idea doesn't fit, explain why clearly and kindly, then suggest alternatives or modifications.
+  *   **One Main Idea at a Time:** To avoid confusion, try to focus the discussion on one main project idea or a small set of comparable alternatives at any given time.
+  *   **User-Centric:** Your goal is to help the user find a project *they* will be happy and successful with.
+  *   **Clarity:** Be clear in your suggestions and questions.
+  *   **Tool Protocol:** When you decide to use `human_assistance`, formulate the tool call correctly. Do not try to answer the question you intend to ask the user.
+
+  ---
+  **Examples of How You Should Operate in Brainstorming Mode:**
+
+  **Example 1: Initial Interaction, User is Vague**
+  User Message: "I want to make something for my room."
+
+  THOUGHT:
+  The user has a general interest (something for their room) but no specific idea. I need to gather more information about their preferences or suggest some categories while keeping the DIY criteria in mind. I will use `human_assistance` to ask a clarifying question.
+  My plan is to:
+  1. Acknowledge their interest.
+  2. Ask for more details about what kind of item or style they like for their room, using the `human_assistance` tool.
+  Tool: `human_assistance`
+  Argument `query`: "That's a great starting point! To help me suggest some ideas, what kind of item are you thinking of for your room? For example, are you looking for some decor, a small piece of furniture, or something for organization?"
+
+  (LLM then generates the tool call for `human_assistance` with the above query.)
+
+  RESPONSE SYNTHESIS:
+  (The system would show the tool call. If a textual response is also generated by the LLM before the tool call, it might be: "Okay, let's brainstorm some ideas for your room!")
+
+  ---
+  **Example 2: User Suggests an Idea that Needs Refinement**
+  User Message: "I'd like to build a custom LED matrix display powered by a Raspberry Pi."
+
+  THOUGHT:
+  The user's idea ("custom LED matrix display powered by a Raspberry Pi") involves specialized electronic components (LED matrix, Raspberry Pi) which violates one of the Critical Criteria. I need to gently explain this and suggest an alternative that fits the criteria, or ask if they are open to a non-electronic project with a similar theme if possible.
+  My plan is to:
+  1. Acknowledge the coolness of their idea.
+  2. Explain the constraint regarding specialized electronics.
+  3. Propose a simpler, non-electronic decorative item or ask if they have other interests that fit the criteria using `human_assistance`.
+  Tool: `human_assistance`
+  Argument `query`: "A custom LED display sounds like a very cool project! For the kinds of DIY projects we're focusing on here, we try to stick to materials and tools easily found in regular hardware or craft stores, avoiding specialized electronics like Raspberry Pis for now. Would you be interested in brainstorming a different kind of decorative item for your room, perhaps using wood, paint, or fabric? Or is there another type of project you've been thinking about?"
+
+  (LLM then generates the tool call.)
+
+  RESPONSE SYNTHESIS:
+  (Similar to above, LLM outputs the tool call.)
+
+  ---
+  **Example 3: Idea Converging and Meeting Criteria**
+  User Message: "Okay, a simple hanging planter made from reclaimed wood sounds good. I think I can manage that."
+
+  THOUGHT:
+  The user is positive about "simple hanging planter made from reclaimed wood."
+  Let's check criteria:
+  1. Buildable: "Simple hanging planter" sounds buildable with basic skills.
+  2. Common Materials/Tools: "Reclaimed wood" is common, and tools would be basic (saw, drill, screws/rope).
+  3. Avoid Specializations: No electronics or complex machinery.
+  4. Tangible Product: Yes, it's a physical planter.
+  All criteria seem met, and the user sounds agreeable. I should output the `IDEA FINALIZED` signal.
+
+  RESPONSE SYNTHESIS:
+  IDEA FINALIZED: Simple hanging planter from reclaimed wood
+
+  ---
+  **Example 4: Brainstorming without immediate tool use**
+  User Message: (After AI asked "What kind of materials do you like?") "I like working with wood, but I'm a beginner."
+
+  THOUGHT:
+  The user likes wood and is a beginner. I should suggest a simple wooden project that fits the criteria. I don't need to ask another question immediately. I can make a direct suggestion.
+  My plan is to:
+  1. Acknowledge their preference and skill level.
+  2. Propose 1-2 simple beginner-friendly wooden project ideas that meet all criteria.
+  No tool needed for this specific turn.
+
+  RESPONSE SYNTHESIS:
+  That's great! Wood is very versatile. For a beginner, how about a simple wooden coaster set, a small picture frame, or perhaps a basic bookend? These projects use minimal materials and are good for practicing fundamental skills. Do any of those sound interesting, or would you like other suggestions?
+Use code with caution.
+How this maps to your brainstorming_node code:
+guidance_prompt_text becomes this new system prompt:
+Instead of your current guidance_prompt_text which is a partial instruction, you would replace it entirely with the detailed prompt above.
+# In your brainstorming_node.py (or wherever model components are defined)
+BRAINSTORMING_SYSTEM_PROMPT = """
+You are a creative and helpful AI assistant acting as a DIY Project Brainstorming Facilitator...
+... (rest of the detailed prompt above) ...
+"""
+Use code with caution.
+Python
+Constructing final_prompt:
+Your code currently does:
+final_prompt = "\n".join([guidance_prompt_text, state.prompt, ASSISTANT_SYSTEM_PROMPT_BASE])
+With the new approach, ASSISTANT_SYSTEM_PROMPT_BASE (the original methodical prompt) is no longer suitable to be appended directly as it would conflict.
+You should simplify this to:
+# In your brainstorming_node function
+# Remove the old guidance_prompt_text variable from within the function if BRAINSTORMING_SYSTEM_PROMPT is defined globally/imported
+
+system_message_content = BRAINSTORMING_SYSTEM_PROMPT
+if state.prompt: # If there's a new user message relevant to this turn
+    system_message_content += f"\n\nConsider the user's latest input: {state.prompt}"
+
+prompt = ChatPromptTemplate.from_messages(
+    [
+        ("system", system_message_content),
+        MessagesPlaceholder(variable_name="messages"), # for conversation history
+    ]
+)
+Use code with caution.
+Python
+The state.prompt (if it represents the very latest user query/message for the current turn) can be appended to the system prompt or, more typically, be the last HumanMessage in the state.messages list. The MessagesPlaceholder will handle the history.
+Tool Binding:
+Your existing assistant_model = model.bind_tools([human_assistance]) is correct. The new prompt now clearly instructs the LLM when and how to call human_assistance.
+Logic for IDEA FINALIZED::
+Your existing code:
+if content.startswith("IDEA FINALIZED:"):
+    print('✅ final idea')
+    updates.update({
+        "brainstorming_complete": True,
+        # ...
+    })
+Use code with caution.
+Python
+This perfectly matches the new prompt's instruction for signaling finalization.
+By using this tailored system prompt, the LLM will have a much clearer understanding of its role, goals, constraints, and expected output format for the brainstorming phase, making it more effective in guiding the user to a suitable DIY project idea.

brainstorming_system_prompt.txt

@@ -0,0 +1,56 @@
+=# Assume this is defined globally or imported
+# This is the detailed prompt I provided in the previous answer.
+# Make sure this string ITSELF does not contain unresolved f-string placeholders like {status_summary}
+# or accidental placeholders like {\n "brainstorming_complete"} or {state.prompt}
+BRAINSTORMING_FACILITATOR_SYSTEM_PROMPT = """
+You are a creative and helpful AI assistant acting as a **DIY Project Brainstorming Facilitator**. Your primary goal is to collaborate with the user to finalize **ONE specific, viable DIY project idea**. You will achieve this by understanding user preferences, suggesting ideas, refining them collaboratively, and using the `human_assistance` tool for direct user interaction and clarification.
+
+**Critical Criteria for the Final DIY Project Idea (MUST be met):**
+1.  **Buildable:** Achievable by an average person with basic DIY skills.
+2.  **Common Materials/Tools:** Uses only materials (e.g., wood, screws, glue, paint, fabric, cardboard) and basic hand tools (e.g., screwdrivers, hammers, saws, drills) commonly available in general hardware stores, craft stores, or supermarkets worldwide.
+3.  **Avoid Specializations:** Explicitly AVOID projects requiring specialized electronic components, 3D printing, specific brand items not universally available, or complex machinery.
+4.  **Tangible Product:** The final result must be a physical, tangible item.
+
+**Your Process for Each Brainstorming Interaction Cycle:**
+
+1.  **THOUGHT:**
+    *   First, clearly state your understanding of the user's current input or the state of the brainstorming (e.g., "User is looking for initial ideas," "User proposed an idea that needs refinement against criteria," "We are close to finalizing an idea.").
+    *   Outline your plan for this interaction turn. This usually involves:
+        *   Engaging with the user's latest message.
+        *   Proposing a new idea or refining an existing one to meet the **Critical Criteria**.
+        *   Identifying if a question to the user is needed.
+    *   **Tool Identification (`human_assistance`):** If you need to ask the user a question to:
+        *   Understand their interests or initial thoughts.
+        *   Clarify their preferences or skill level (gently).
+        *   Get feedback on a proposed idea.
+        *   Refine an idea to meet criteria.
+        You MUST state your intention to use the `human_assistance` tool and clearly formulate the question you will pass as the `query` argument.
+    *   **Idea Finalization Check:** If you believe a current idea, discussed with the user, clearly meets ALL **Critical Criteria** and the user seems positive, note your intention to output the `IDEA FINALIZED` signal.
+
+2.  **TOOL USE (`human_assistance` - If Necessary):**
+    *   If your plan requires asking the user a question, you will then invoke the `human_assistance` tool with your formulated query.
+    *   (Agent Builder Note: The LLM will output a tool call here. The system executes it.)
+
+3.  **RESPONSE SYNTHESIS / IDEA FINALIZATION:**
+    *   After any necessary tool use (or if no tool was needed for this turn), synthesize your response.
+    *   **If an idea is finalized:** When you determine that a specific project idea meets ALL **Critical Criteria** and the user has positively engaged with it, your response for this turn MUST BE *ONLY* 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. This signals the end of brainstorming.
+    *   **If brainstorming continues (no finalization yet):**
+        *   Provide your conversational response, suggestions, or refinements.
+        *   If you didn't use a tool in step 2 but are now responding, ensure your response is engaging and moves the brainstorming forward.
+        *   If you just made a tool call for `human_assistance`, your main output here might be the tool call itself, or a very brief lead-in text if the system allows. Await the user's response to your question (which will come as a new message).
+
+**General Guidelines for Your Interaction:**
+*   **Collaborative & Iterative:** Work *with* the user. It's a conversation.
+*   **Criteria Focused:** Always gently guide ideas towards meeting all **Critical Criteria**. If a user's idea doesn't fit, explain why clearly and kindly, then suggest alternatives or modifications.
+*   **One Main Idea at a Time:** To avoid confusion, try to focus the discussion on one main project idea or a small set of comparable alternatives at any given time.
+*   **User-Centric:** Your goal is to help the user find a project *they* will be happy and successful with.
+*   **Clarity:** Be clear in your suggestions and questions.
+*   **Tool Protocol:** When you decide to use `human_assistance`, formulate the tool call correctly. Do not try to answer the question you intend to ask the user.
+
+---
+**Examples of How You Should Operate in Brainstorming Mode:** (Include examples as before)
+... (rest of the prompt) ...
+"""

curls

@@ -0,0 +1,26 @@
+PowerShell 7.5.1
+PS C:\Users\jayan> curl "https://wishwa-code--trellis-3d-model-generate-dev.modal.run/?image_url=A chair looking like a avocado?q=80&w=1974&auto=format&fit=crop&ixlib=rb-4.1.0&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&simplify=0.95&texture_size=1024&sparse_sampling_steps=12&sparse_sampling_cfg=7.5&slat_sampling_steps=12&slat_sampling_cfg=3&seed=42&output_format=glb" --output model1.glb
+curl: (3) URL rejected: Malformed input to a URL function
+PS C:\Users\jayan> curl "https://wishwa-code--trellis-3d-model-generate-dev.modal.run/?image_url=A%chair%looking%like%a%avocado?q=80&w=1974&auto=format&fit=crop&ixlib=rb-4.1.0&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&simplify=0.95&texture_size=1024&sparse_sampling_steps=12&sparse_sampling_cfg=7.5&slat_sampling_steps=12&slat_sampling_cfg=3&seed=42&output_format=glb" --output model1.glb
+  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
+                                 Dload  Upload   Total   Spent    Left  Speed
+100    90  100    90    0     0      1      0  0:01:30  0:00:50  0:00:40    20
+PS C:\Users\jayan>  curl "https://wishwa-code--trellis-3d-model-generate-dev.modal.run/?image_url=A%chair%looking%like%a%avocado?q=80&w=1974&auto=format&fit=crop&ixlib=rb-4.1.0&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&simplify=0.95&texture_size=1024&sparse_sampling_steps=12&sparse_sampling_cfg=7.5&slat_sampling_steps=12&slat_sampling_cfg=3&seed=42&output_format=glb" --output model1.glb
+  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
+                                 Dload  Upload   Total   Spent    Left  Speed
+  0     0    0     0    0     0      0      0 --:--:--  0:00:50 --:--:--     0
+PS C:\Users\jayan> ^C
+PS C:\Users\jayan> ^C
+PS C:\Users\jayan> ^C
+PS C:\Users\jayan> curl "https://wishwa-code--trellis-3d-model-generate-dev.modal.run/?image_url=A%chair%looking%like%a%avocado?q=80&w=1974&auto=format&fit=crop&ixlib=rb-4.1.0&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&simplify=0.95&texture_size=1024&sparse_sampling_steps=12&sparse_sampling_cfg=7.5&slat_sampling_steps=12&slat_sampling_cfg=3&seed=42&output_format=glb" --output model1.glb
+  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
+                                 Dload  Upload   Total   Spent    Left  Speed
+100    90  100    90    0     0      1      0  0:01:30  0:01:07  0:00:23    20
+PS C:\Users\jayan> curl "https://wishwa-code--trellis-3d-model-generate-dev.modal.run/?image_url=https://images.unsplash.com/photo-1748973750733-d037dded16dd?q=80&w=1974&auto=format&fit=crop&ixlib=rb-4.1.0&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&simplify=0.95&texture_size=1024&sparse_sampling_steps=12&sparse_sampling_cfg=7.5&slat_sampling_steps=12&slat_sampling_cfg=3&seed=42&output_format=glb" --output model1.glb
+  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
+                                 Dload  Upload   Total   Spent    Left  Speed
+100 1820k  100 1820k    0     0  18953      0  0:01:38  0:01:38 --:--:--  140k
+PS C:\Users\jayan>
+
+
+

graph.py

@@ -0,0 +1,1298 @@
+
+
+import logging
+import os
+import uuid
+import aiohttp
+import json
+import httpx
+
+from typing import Annotated
+from typing import TypedDict, List, Optional, Literal
+
+from typing_extensions import TypedDict
+from pydantic import BaseModel, Field
+from trafilatura import extract
+
+from langchain_core.messages import AIMessage, HumanMessage, AnyMessage, ToolCall, SystemMessage, ToolMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.tools import tool
+
+from langchain_community.tools import TavilySearchResults
+
+from langgraph.graph.state import CompiledStateGraph
+from langgraph.graph import StateGraph, START, END, add_messages
+
+from langgraph.prebuilt import ToolNode
+from langgraph.prebuilt import ToolNode, tools_condition
+
+from langgraph.checkpoint.memory import MemorySaver
+
+from langgraph.types import Command, interrupt
+
+from langchain_anthropic import ChatAnthropic
+from langchain_openai import ChatOpenAI
+
+from mistralai import Mistral
+from langchain.chat_models import init_chat_model
+from langchain_core.messages.utils import convert_to_openai_messages
+
+
+
+class State(TypedDict):
+    messages: Annotated[list, add_messages]
+
+class DebugToolNode(ToolNode):
+    async def invoke(self, state, config=None):
+        print("🛠️ ToolNode activated")
+        print(f"Available tools: {[tool.name for tool in self.tool_map.values()]}")
+        print(f"Tool calls in last message: {state.messages[-1].tool_calls}")
+        return await super().invoke(state, config)
+
+
+logger = logging.getLogger(__name__)
+ASSISTANT_SYSTEM_PROMPT_BASE = """"""
+search_enabled = bool(os.environ.get("TAVILY_API_KEY"))
+
+try:
+    with open('brainstorming_system_prompt.txt', 'r') as file:
+        brainstorming_system_prompt = file.read()
+except FileNotFoundError:
+    print("File 'system_prompt.txt' not found!")
+except Exception as e:
+    print(f"Error reading file: {e}")
+
+def evaluate_idea_completion(response) -> bool:
+    """
+    Evaluates whether the assistant's response indicates a complete DIY project idea.
+    You can customize the logic based on your specific criteria.
+    """
+    # Example logic: Check if the response contains certain keywords
+    required_keywords = ["materials", "dimensions", "tools", "steps"]
+
+    # Determine the type of response and extract text accordingly
+    if isinstance(response, dict):
+        # If response is a dictionary, extract values and join them into a single string
+        response_text = ' '.join(str(value).lower() for value in response.values())
+    elif isinstance(response, str):
+        # If response is a string, convert it to lowercase
+        response_text = response.lower()
+    else:
+        # If response is of an unexpected type, convert it to string and lowercase
+        response_text = str(response).lower()
+
+    return all(keyword in response_text for keyword in required_keywords)
+
+@tool
+async def human_assistance(query: str) -> str:
+    """Request assistance from a human."""
+    human_response = await interrupt({"query": query})  # async wait
+    return human_response["data"]
+
+@tool
+async def download_website_text(url: str) -> str:
+    """Download the text from a website"""
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as response:
+                response.raise_for_status()
+                downloaded = await response.text()
+        result = extract(downloaded, include_formatting=True, include_links=True, output_format='json', with_metadata=True)
+        return result or "No text found on the website"
+    except Exception as e:
+        logger.error(f"Failed to download {url}: {str(e)}")
+        return f"Error retrieving website content: {str(e)}"
+    
+@tool
+async def finalize_idea() -> str:
+    """Marks the brainstorming phase as complete. This function does nothing else."""
+    return "Brainstorming finalized."
+
+tools = [download_website_text, human_assistance,finalize_idea]
+memory = MemorySaver()
+
+
+if search_enabled:
+    tavily_search_tool = TavilySearchResults(
+        max_results=5,
+        search_depth="advanced",
+        include_answer=True,
+        include_raw_content=True,
+    )
+    tools.append(tavily_search_tool)
+else:
+    print("TAVILY_API_KEY environment variable not found. Websearch disabled")
+
+weak_model = ChatOpenAI(
+        model="gpt-4o",
+        temperature=0,
+        max_tokens=None,
+        timeout=None,
+        max_retries=2,
+        # api_key="...",  # if you prefer to pass api key in directly instaed of using env vars
+        # base_url="...",
+        # organization="...",
+        # other params...
+    )
+
+api_key = os.environ["MISTRAL_API_KEY"]
+model = "mistral-large-latest"
+
+client = Mistral(api_key=api_key)
+
+
+# ChatAnthropic(
+#             model="claude-3-5-sonnet-20240620",
+#             temperature=0,
+#             max_tokens=1024,
+#             timeout=None,
+#             max_retries=2,
+#             # other params...
+#         )
+search_enabled = bool(os.environ.get("TAVILY_API_KEY"))
+
+if not os.environ.get("OPENAI_API_KEY"):
+    print('Open API key not found')
+
+prompt_planning_model = ChatOpenAI(
+        model="gpt-4o",
+        temperature=0,
+        max_tokens=None,
+        timeout=None,
+        max_retries=2,
+        # api_key="...",  # if you prefer to pass api key in directly instaed of using env vars
+        # base_url="...",
+        # organization="...",
+        # other params...
+    )
+
+threed_object_gen_model = ChatOpenAI(
+        model="gpt-4o",
+        temperature=0,
+        max_tokens=None,
+        timeout=None,
+        max_retries=2,
+        # api_key="...",  # if you prefer to pass api key in directly instaed of using env vars
+        # base_url="...",
+        # organization="...",
+        # other params...
+    )
+
+model = weak_model
+assistant_model = weak_model
+
+class GraphProcessingState(BaseModel):
+    # user_input: str = Field(default_factory=str, description="The original user input")
+    messages: Annotated[list[AnyMessage], add_messages] = Field(default_factory=list)
+    prompt: str = Field(default_factory=str, description="The prompt to be used for the model")
+    tools_enabled: dict = Field(default_factory=dict, description="The tools enabled for the assistant")
+    search_enabled: bool = Field(default=True, description="Whether to enable search tools")
+    next_stage: str = Field(default="", description="The next stage to execute, decided by the guidance node.")
+
+    tool_call_required: bool = Field(default=False, description="Whether a tool should be called from brainstorming.")
+    loop_brainstorming: bool = Field(default=False, description="Whether to loop back to brainstorming for further iteration.")
+
+    # Completion flags for each stage
+    idea_complete: bool = Field(default=False)
+    brainstorming_complete: bool = Field(default=False)
+    planning_complete: bool = Field(default=False)
+    drawing_complete: bool = Field(default=False)
+    product_searching_complete: bool = Field(default=False)
+    purchasing_complete: bool = Field(default=False)
+
+    
+    generated_image_url_from_dalle: str = Field(default="", description="The generated_image_url_from_dalle.")
+
+
+
+async def guidance_node(state: GraphProcessingState, config=None):
+
+    # print(f"Prompt: {state.prompt}")
+    # print(f"Prompt: {state.prompt}")
+    # # print(f"Message: {state.messages}")
+    # print(f"Tools Enabled: {state.tools_enabled}")
+    # print(f"Search Enabled: {state.search_enabled}")
+    # for message in state.messages:
+    #     print(f'\ncomplete message', message)
+    #     if isinstance(message, HumanMessage):
+    #         print(f"Human: {message.content}\n")
+    #     elif isinstance(message, AIMessage):
+    #         # Check if content is non-empty
+    #         if message.content:
+    #             # If content is a list (e.g., list of dicts), extract text
+    #             if isinstance(message.content, list):
+    #                 texts = [item.get('text', '') for item in message.content if isinstance(item, dict) and 'text' in item]
+    #                 if texts:
+    #                     print(f"AI: {' '.join(texts)}\n")
+    #             elif isinstance(message.content, str):
+    #                 print(f"AI: {message.content}")
+    #     elif isinstance(message, SystemMessage):
+    #         print(f"System: {message.content}\n")
+    #     elif isinstance(message, ToolMessage):
+    #         print(f"Tool: {message.content}\n")
+    print("\n🕵️‍♀️🕵️‍♀️ |  start | progress checking nodee \n") # Added a newline for clarity
+
+    # print(f"Prompt: {state.prompt}\n")
+
+    if state.messages:
+        last_message = state.messages[-1]
+
+        if isinstance(last_message, HumanMessage):
+            print(f"🧑 Human: {last_message.content}\n")
+        elif isinstance(last_message, AIMessage):
+            if last_message.content:
+                if isinstance(last_message.content, list):
+                    texts = [item.get('text', '') for item in last_message.content if isinstance(item, dict) and 'text' in item]
+                    if texts:
+                        print(f"🤖 AI: {' '.join(texts)}\n")
+                elif isinstance(last_message.content, str):
+                    print(f"🤖 AI: {last_message.content}\n")
+        elif isinstance(last_message, SystemMessage):
+            print(f"⚙️ System: {last_message.content}\n")
+        elif isinstance(last_message, ToolMessage):
+            print(f"🛠️ Tool: {last_message.content}\n")
+    else:
+        print("\n(No messages found.)")
+
+
+    # Log boolean completion flags
+    # Define the order of stages
+    stage_order = ["brainstorming", "planning", "drawing", "product_searching", "purchasing"]
+    
+    # Identify completed and incomplete stages
+    completed = [stage for stage in stage_order if getattr(state, f"{stage}_complete", False)]
+    incomplete = [stage for stage in stage_order if not getattr(state, f"{stage}_complete", False)]
+    
+    
+
+    # Determine the next stage
+    if not incomplete:
+        # All stages are complete
+        return {
+            "messages": [AIMessage(content="All DIY project stages are complete!")],
+            "next_stage": "end_project",
+            "pending_approval_stage": None,
+        }
+    else:
+        # Set the next stage to the first incomplete stage
+        next_stage = incomplete[0]
+        print(f"Next Stage: {state.next_stage}")
+        print("\n🕵️‍♀️🕵️‍♀️ |  end | progress checking nodee \n") # Added a newline for clarity
+        return {
+            "messages": [],
+            "next_stage": next_stage,
+            "pending_approval_stage": None,
+        }
+        
+def guidance_routing(state: GraphProcessingState) -> str:
+
+    print("\n🔀🔀 Routing checkpoint 🔀🔀\n")    
+    
+    print(f"Next Stage: {state.next_stage}\n")
+
+    print(f"Brainstorming complete: {state.brainstorming_complete}")
+    print(f"Prompt planing: {state.planning_complete}")
+    print(f"Drwaing 3d model: {state.drawing_complete}")
+    print(f"Finding products: {state.product_searching_complete}\n")
+
+
+    
+    next_stage = state.next_stage
+    if next_stage == "brainstorming":
+        return "brainstorming_node"
+
+    elif next_stage == "planning":
+        # return "generate_3d_node"
+        return "prompt_planning_node"
+    elif next_stage == "drawing":
+        return "generate_3d_node"
+    elif next_stage == "product_searching":
+        print('\n may day may day may day may day may day')  
+        
+        print(f"Prompt: {state.prompt}")
+        print(f"Prompt: {state.prompt}")
+        # print(f"Message: {state.messages}")
+        print(f"Tools Enabled: {state.tools_enabled}")
+        print(f"Search Enabled: {state.search_enabled}")
+        for message in state.messages:
+            print(f'\ncomplete message', message)
+            if isinstance(message, HumanMessage):
+                print(f"Human: {message.content}\n")
+            elif isinstance(message, AIMessage):
+                # Check if content is non-empty
+                if message.content:
+                    # If content is a list (e.g., list of dicts), extract text
+                    if isinstance(message.content, list):
+                        texts = [item.get('text', '') for item in message.content if isinstance(item, dict) and 'text' in item]
+                        if texts:
+                            print(f"AI: {' '.join(texts)}\n")
+                    elif isinstance(message.content, str):
+                        print(f"AI: {message.content}")
+            elif isinstance(message, SystemMessage):
+                print(f"System: {message.content}\n")
+            elif isinstance(message, ToolMessage):
+                print(f"Tool: {message.content}\n")
+    #     return "drawing_node"
+    # elif next_stage == "product_searching":
+    #     return "product_searching"
+    # elif next_stage == "purchasing":
+    #     return "purchasing_node"
+        return END    
+
+async def brainstorming_node(state: GraphProcessingState, config=None):
+    print("\n🧠🧠 |  start | brainstorming Node \n") # Added a newline for clarity
+
+
+    # Check if model is available
+    if not model:
+        return {"messages": [AIMessage(content="Model not available for brainstorming.")]}
+
+    # Filter out messages with empty content
+    filtered_messages = [
+        message for message in state.messages
+        if isinstance(message, (HumanMessage, AIMessage, SystemMessage, ToolMessage)) and message.content
+    ]
+
+    # Ensure there is at least one message with content
+    if not filtered_messages:
+        filtered_messages.append(AIMessage(content="No valid messages provided."))
+
+    stage_order = ["brainstorming", "planning", "drawing", "product_searching", "purchasing"]
+    completed = [stage for stage in stage_order if getattr(state, f"{stage}_complete", False)]
+    incomplete = [stage for stage in stage_order if not getattr(state, f"{stage}_complete", False)]
+
+    if not incomplete:
+        print("All stages complete!")
+        # Handle case where all stages are complete
+        # You might want to return a message and end, or set proposed_next_stage to a special value
+        ai_all_complete_msg = AIMessage(content="All DIY project stages are complete!")
+        return {
+            "messages": current_messages + [ai_all_complete_msg],
+            "next_stage": "end_project", # Or None, or a final summary node
+            "pending_approval_stage": None,
+        }
+    else:
+        # THIS LINE DEFINES THE VARIABLE
+        proposed_next_stage = incomplete[0]
+
+    guidance_prompt_text = (
+    """
+        You are a warm, encouraging, and knowledgeable AI assistant, acting as a **Creative DIY Collaborator**. Your primary goal is to guide the user through a friendly and inspiring conversation to finalize **ONE specific, viable DIY project idea**. While we want to be efficient, the top priority is making the user feel heard, understood, and confident in their final choice.
+
+        ⚠️ Your core directive remains speed and convergence: If you identify an idea that clearly meets ALL **Critical Criteria** and the user seems positive or neutral, you must suggest finalizing it **immediately**. Do NOT delay by offering too many alternatives once a solid candidate emerges. Your goal is to converge on a "good enough" idea the user is happy with, not to explore every possibility.
+
+        **Your Conversational Style & Strategy:**
+        1.  **Be an Active Listener:** Start by acknowledging and validating the user's input. Show you understand their core desire (e.g., "That sounds like a fun goal! Creating a custom piece for your living room is always rewarding.").
+        2.  **Ask Inspiring, Open-Ended Questions:** Instead of generic questions, make them feel personal and insightful.
+            * *Instead of:* "What do you want to build?"
+            * *Try:* "What part of your home are you dreaming of improving?" or "Are you thinking of a gift for someone special, or a project just for you?"
+        3.  **Act as a Knowledgeable Guide:** When a user is unsure, proactively suggest appealing ideas based on their subtle clues. Connect their interests to tangible projects.
+            * *Example:* If the user mentions liking plants and having a small balcony, you could suggest: "That's great! We could think about a vertical herb garden to save space, or maybe some simple, stylish hanging macrame planters. Does either of those spark your interest?"
+        4.  **Guide, Don't Just Gatekeep:** When an idea *almost* meets the criteria, don't just reject it. Gently guide it towards feasibility.
+            * *Example:* "A full-sized dining table might require some specialized tools. How about we adapt that idea into a beautiful, buildable coffee table or a set of side tables using similar techniques?"
+
+        **Critical Criteria for the Final DIY Project Idea (Your non-negotiable checklist):**
+        1.  **Buildable:** Achievable by an average person with basic DIY skills.
+        2.  **Common Materials/Tools:** Uses only materials (e.g., wood, screws, glue, paint, fabric, cardboard) and basic hand tools (e.g., screwdrivers, hammers, saws, drills) commonly available in general hardware stores, craft stores, or supermarkets worldwide.
+        3.  **Avoid Specializations:** Explicitly AVOID projects requiring specialized electronic components, 3D printing, specific brand items not universally available, or complex machinery.
+        4.  **Tangible Product:** The final result must be a physical, tangible item.
+
+        **Your Internal Process (How you think on each turn):**
+
+        1.  **THOUGHT:**
+            * Clearly state your understanding of the user’s current input and conversational state.
+            * Outline your plan: Engage with their latest input using your **Conversational Style**. Propose or refine an idea to meet the **Critical Criteria**.
+            * **Tool Identification (`human_assistance`):** Decide if you need to ask a question. The question should be formulated according to the "Inspiring, Open-Ended Questions" principle. Clearly state your intention to use the `human_assistance` tool with the exact friendly and natural-sounding question as the `query`.
+            * **Idea Finalization Check:** Check if the current idea satisfies ALL **Critical Criteria**. If yes, and the user shows no objection, move to finalize immediately. Remember: **good enough is final enough**.
+
+        2.  **TOOL USE (`human_assistance` - If Needed):**
+            * Invoke `human_assistance` with your well-formulated, friendly query.
+
+        3.  **RESPONSE SYNTHESIS / IDEA FINALIZATION:**
+            * **If an idea is finalized:** Respond *only* with the exact phrase:
+                `IDEA FINALIZED: [Name of the Idea]`
+                (e.g., `IDEA FINALIZED: Simple Wooden Spice Rack`)
+            * **If brainstorming continues:**
+                * Provide your engaging suggestions or refinements based on your **Conversational Style**.
+                * Await the user response.
+
+        **General Guidelines (Your core principles):**
+        * **Empathy Over Pure Efficiency:** A positive, collaborative experience is the primary goal. Don't rush the user if they are still exploring.
+        * **Criteria Focused:** Always gently guide ideas toward the **Critical Criteria**.
+        * **One Main Idea at a Time:** Focus the conversation on a single project idea to avoid confusion.
+        * **Rapid Convergence:** Despite the friendly tone, always be looking for the fastest path to a final, viable idea.
+    """
+)
+
+
+
+    if state.prompt:
+        final_prompt = "\n".join([ guidance_prompt_text, state.prompt, ASSISTANT_SYSTEM_PROMPT_BASE])
+    else:
+        final_prompt = "\n".join([ guidance_prompt_text, ASSISTANT_SYSTEM_PROMPT_BASE])
+
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", final_prompt),
+            MessagesPlaceholder(variable_name="messages"),
+        ]
+    )
+
+    # Tools allowed for brainstorming
+    node_tools = [human_assistance]
+    if state.search_enabled and tavily_search_tool:  # only add search tool if enabled and initialized
+        node_tools.append(tavily_search_tool)
+
+    
+
+
+    mistraltools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "human_assistance",
+                "description": "Ask a question from the user",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "query": "The transaction id.",
+                        }
+                    },
+                    "required": ["query"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "finalize_idea",
+                "description": "Handles finalized ideas. Saves or dispatches the confirmed idea for the next steps. but make sure you give your response with key word IDEA FINALIZED",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "idea_name": {
+                            "type": "string",
+                            "description": "The name of the finalized DIY idea.",
+                        }
+                    },
+                    "required": ["idea_name"]
+                }
+            }
+        }
+    ]
+    llm = init_chat_model("mistral-large-latest", model_provider="mistralai")
+
+    llm_with_tools = llm.bind_tools(mistraltools)
+    chain = prompt | llm_with_tools
+
+    openai_messages = convert_to_openai_messages(state.messages)
+
+    openai_messages_with_prompt = [
+        {"role": "system", "content": final_prompt},  # your guidance prompt
+        *openai_messages  # history you’ve already converted
+    ]
+
+    print('open ai formatted', openai_messages_with_prompt[-1])
+
+    for msg in openai_messages_with_prompt:
+        print(msg)
+
+    mistralmodel = "mistral-saba-2502"
+
+    # Pass filtered messages to the chain
+    try:
+    
+        # response = await chain.ainvoke({"messages": filtered_messages}, config=config)
+        response = client.chat.complete(
+            model = mistralmodel,
+            messages = openai_messages_with_prompt,
+            tools = mistraltools,
+            tool_choice = "any",
+            parallel_tool_calls = False,
+        )
+
+        mistral_message = response.choices[0].message
+        tool_call = response.choices[0].message.tool_calls[0]
+        function_name = tool_call.function.name
+        function_params = json.loads(tool_call.function.arguments)
+
+        ai_message = AIMessage(
+            content=mistral_message.content or "",  # Use empty string if blank
+            additional_kwargs={
+                "tool_calls": [
+                    {
+                        "id": tool_call.id,
+                        "function": {
+                            "name": tool_call.function.name,
+                            "arguments": tool_call.function.arguments,
+                        },
+                        "type": "function",  # Add this if your chain expects it
+                    }
+                ]
+            }
+        )
+
+        updates = {
+            "messages": [ai_message],
+            "tool_calls": [
+                {
+                    "name": function_name,
+                    "arguments": function_params,
+                }
+            ],
+            "next": function_name,
+        }
+
+        print("\nfunction_name: ", function_name, "\nfunction_params: ", function_params)
+        print('\n🔍 response from brainstorm\n', updates)
+
+        if function_name == "finalize_idea":
+            print('finalazing idea')
+            state.brainstorming_complete = True
+            updates["brainstorming_complete"] = True
+
+
+        if isinstance(response, AIMessage) and response.content:
+            print(' Identified last AI message', response)
+            if isinstance(response.content, str):
+                content = response.content.strip()
+            elif isinstance(response.content, list):
+                texts = [item.get("text", "") for item in response.content if isinstance(item, dict)]
+                content = " ".join(texts).strip()
+            else:
+                content = str(response.content).strip()
+
+            print('content for idea finalizing:', content)
+            if "finalize_idea:" in content:  # Use 'in' instead of 'startswith'
+                print('✅ final idea')
+                updates.update({
+                    "brainstorming_complete": True,
+                    "tool_call_required": False,
+                    "loop_brainstorming": False,
+                })
+                return updates
+
+            else:
+                # tool_calls = getattr(response, "tool_calls", None)
+                
+
+                if tool_call:
+                    print('🛠️ tool call requested at  brainstorming node')
+                    updates.update({
+                        "tool_call_required": True,
+                        "loop_brainstorming": False,
+                    })
+
+                if tool_call:
+                    tool_call = response.choices[0].message.tool_calls[0]
+                    function_name = tool_call.function.name
+                    function_params = json.loads(tool_call.function.arguments)
+                    print("\nfunction_name: ", function_name, "\nfunction_params: ", function_params)
+                    # for tool_call in response.tool_calls:
+                    #     tool_name = tool_call['name']
+                    #     if tool_name == "human_assistance":
+                    #         query = tool_call['args']['query']
+                    #         print(f"Human input needed: {query}")
+
+                    # for tool_call in tool_calls:
+                    #     if isinstance(tool_call, dict) and 'name' in tool_call and 'args' in tool_call:
+                    #         print(f"🔧 Tool Call (Dict): {tool_call.get('name')}, Args: {tool_call.get('args')}")
+                    #     else:
+                    #         print(f"🔧 Unknown tool_call format: {tool_call}")
+                else:
+                    print('💬 decided tp keep brainstorming')
+                    updates.update({
+                        "tool_call_required": False,
+                        "loop_brainstorming": True,
+                    })
+                    print(f"Brainstorming continues: {content}")
+
+        else:
+            # If no proper response, keep looping brainstorming
+            updates["tool_call_required"] = False
+            updates["loop_brainstorming"] = True
+
+        print("\n🧠🧠 |  end | brainstorming Node \n")
+        return updates
+    except Exception as e:
+        print(f"Error: {e}")
+        return {
+            "messages": [AIMessage(content="Error.")],
+            "next_stage": "brainstorming"
+        }
+
+
+async def prompt_planning_node(state: GraphProcessingState, config=None):
+    print("\n🚩🚩 |  start | prompt planing Node \n")
+    # Ensure we have a model
+    if not model:
+        return {"messages": [AIMessage(content="Model not available for planning.")]}
+
+
+    filtered_messages = state.messages
+    
+    # Filter out empty messages
+    # filtered_messages = [
+    #     msg for msg in state.messages
+    #     if isinstance(msg, (HumanMessage, AIMessage, SystemMessage, ToolMessage)) and msg.content
+    # ]
+    # filtered_messages = []
+
+    # for msg in state.messages:
+    #     if isinstance(msg, ToolMessage):
+    #         # 🛠️ ToolMessage needs to be paired with a prior assistant message that called the tool
+    #         tool_name = msg.name or "unknown_tool"
+    #         tool_call_id = msg.tool_call_id or "tool_call_id_missing"
+
+    #         # Simulated assistant message that initiated the tool call
+    #         fake_assistant_msg = AIMessage(
+    #             content="",
+    #             additional_kwargs={
+    #                 "tool_calls": [
+    #                     {
+    #                         "id": tool_call_id,
+    #                         "type": "function",
+    #                         "function": {
+    #                             "name": tool_name,
+    #                             "arguments": json.dumps({"content": msg.content or ""}),
+    #                         }
+    #                     }
+    #                 ]
+    #             }
+    #         )
+
+    #         # Append both in correct sequence
+    #         filtered_messages.append(fake_assistant_msg)
+    #         filtered_messages.append(msg)
+
+    #     elif isinstance(msg, (HumanMessage, AIMessage, SystemMessage)) and msg.content:
+    #         filtered_messages.append(msg)
+
+# Fallback if list ends up empty
+    if not filtered_messages:
+        filtered_messages.append(AIMessage(content="No valid messages provided."))
+      
+
+    # Define the system prompt for planning
+    guidance_prompt_text = """
+You are a creative and helpful AI assistant acting as a **DIY Project Brainstorming & 3D-Prompt Generator**. Your mission is to collaborate with the user to:
+
+1. Brainstorm and refine one specific, viable DIY project idea.
+2. Identify the single key component from that idea that should be 3D-modeled.
+3. Produce a final, precise text prompt for an OpenAI 3D-generation endpoint.
+
+---  
+**Critical Criteria for the DIY Project** (must be met):  
+• Buildable by an average person with only basic DIY skills.  
+• Uses common materials/tools (e.g., wood, screws, glue, paint; hammer, saw, drill).  
+• No specialized electronics, 3D printers, or proprietary parts.  
+• Results in a tangible, physical item.
+
+---  
+**Available Tools**  
+• human_assistance – ask the user clarifying questions.  
+• (optional) your project-specific search tool – look up inspiration or standard dimensions if needed.
+
+---  
+**When the DIY idea is fully detailed and meets all criteria, output exactly and only:**
+
+ACCURATE PROMPT FOR MODEL GENERATING: [Your final single-paragraph prompt here]
+"""
+
+    # Build final prompt
+    if state.prompt:
+        final_prompt = "\n".join([guidance_prompt_text, state.prompt, ASSISTANT_SYSTEM_PROMPT_BASE])
+    else:
+        final_prompt = "\n".join([guidance_prompt_text, ASSISTANT_SYSTEM_PROMPT_BASE])
+
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", final_prompt),
+        MessagesPlaceholder(variable_name="messages"),
+    ])
+
+    # Bind tools
+    node_tools = [human_assistance]
+    if state.search_enabled and tavily_search_tool:
+        node_tools.append(tavily_search_tool)
+
+    llm_with_tools = prompt_planning_model.bind_tools(node_tools)
+    chain = prompt | llm_with_tools
+
+    # print(' 👾👾👾👾Debugging the request going in to prompt planing model')
+    # print("Prompt: ", prompt)
+    # print("chain: ", chain)
+
+    for msg in filtered_messages:
+        print('✨msg : ',msg)
+        print('\n')
+
+    try:
+        response = await chain.ainvoke({"messages": filtered_messages}, config=config)
+
+        print('\nresponse ->: ', response)
+
+        # Log any required human assistance query
+        if hasattr(response, "tool_calls"):
+            for call in response.tool_calls:
+                if call.get("name") == "human_assistance":
+                    print(f"Human input needed: {call['args']['query']}")
+
+        
+
+        updates = {"messages": [response]}
+
+        # Extract response text
+        content = ""
+        if isinstance(response.content, str):
+            content = response.content.strip()
+        elif isinstance(response.content, list):
+            content = " ".join(item.get("text","") for item in response.content if isinstance(item, dict)).strip()
+
+        # Check for finalization signalif "finalize_idea:" in content:
+        if "ACCURATE PROMPT FOR MODEL GENERATING" in content:
+            dalle_prompt_text = content.replace("ACCURATE PROMPT FOR MODEL GENERATING:", "").strip()
+            print(f"\n🤖🤖🤖🤖Extracted DALL-E prompt: {dalle_prompt_text}")
+
+            generated_image_url = None
+            generated_3d_model_url = None # This will store the final 3D model URL
+
+            # --- START: New code for DALL-E and Trellis API calls ---
+            OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+            if not OPENAI_API_KEY:
+                print("Error: OPENAI_API_KEY environment variable not set.")
+                updates["messages"].append(AIMessage(content="OpenAI API key not configured. Cannot generate image."))
+            else:
+                # 1. Call DALL-E API
+                dalle_api_url = "https://api.openai.com/v1/images/generations"
+                dalle_headers = {
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {OPENAI_API_KEY}"
+                }
+
+                _model_to_use_for_dalle_call = "dall-e-2"  # <<< IMPORTANT: Set this to "dall-e-2" or "dall-e-3"
+
+                
+                _processed_prompt_text = dalle_prompt_text  # Start with the original prompt
+                _prompt_was_trimmed_or_issue_found = False
+                _warning_or_error_message_for_updates = None
+
+                max_prompt_lengths = {
+                    "dall-e-2": 1000,
+                    "dall-e-3": 4000,
+                    "gpt-image-1": 32000 # Included for completeness, though payload is for DALL-E
+                }
+
+                if not _processed_prompt_text: # Check for empty prompt
+                    _message = f"Error: The DALL-E prompt for model '{_model_to_use_for_dalle_call}' cannot be empty. API call will likely fail."
+                    print(f"\n🛑🛑🛑🛑 {_message}")
+                    _warning_or_error_message_for_updates = _message
+                    _prompt_was_trimmed_or_issue_found = True
+                    # NOTE: OpenAI API will return an error for an empty prompt.
+                    # If you want to prevent the call entirely here, you could add:
+                    # updates["messages"].append(AIMessage(content=_message))
+                    # return  # or raise an exception
+
+                elif _model_to_use_for_dalle_call in max_prompt_lengths:
+                    _max_len = max_prompt_lengths[_model_to_use_for_dalle_call]
+                    _original_len = len(_processed_prompt_text)
+
+                    if _original_len > _max_len:
+                        _processed_prompt_text = _processed_prompt_text[:_max_len]
+                        _message = (
+                            f"Warning: Prompt for DALL-E ({_model_to_use_for_dalle_call}) was {_original_len} characters. "
+                            f"It has been TRUNCATED to the maximum of {_max_len} characters."
+                        )
+                        print(f"\n⚠️⚠️⚠️⚠️ {_message}")
+                        _warning_or_error_message_for_updates = _message
+                        _prompt_was_trimmed_or_issue_found = True
+                else:
+                    # Model specified in _model_to_use_for_dalle_call is not in our length check dictionary
+                    _message = (
+                        f"Notice: Model '{_model_to_use_for_dalle_call}' not found in pre-defined prompt length limits. "
+                        "Proceeding with the original prompt. API may reject if prompt is too long for this model."
+                    )
+                    print(f"\nℹ️ℹ️ℹ️ℹ️ {_message}")
+                    # You might not want to add this specific notice to 'updates["messages"]' unless it's critical
+                    # _warning_or_error_message_for_updates = _message
+                    # _prompt_was_trimmed_or_issue_found = True # Or not, depending on how you view this
+
+                # Add warning/error to updates if one was generated
+                if _warning_or_error_message_for_updates:
+                    # Check if 'updates' and 'AIMessage' are available in the current scope to avoid errors
+                    if 'updates' in locals() and isinstance(updates, dict) and 'messages' in updates and 'AIMessage' in globals():
+                        updates["messages"].append(AIMessage(content=_warning_or_error_message_for_updates))
+                    elif 'updates' in globals() and isinstance(updates, dict) and 'messages' in updates: # If AIMessage isn't defined, just append string
+                        updates["messages"].append(_warning_or_error_message_for_updates)
+
+
+                # --- Prompt Trimming Logic END ---
+
+                dalle_payload = {
+                    "model": _model_to_use_for_dalle_call, # Use the model determined above
+                    "prompt": _processed_prompt_text,    # Use the processed (potentially trimmed) prompt
+                    "n": 1,
+                    "size": "1024x1024"
+                    # You can add other DALL-E 3 specific params if _model_to_use_for_dalle_call is "dall-e-3"
+                    # e.g., "quality": "hd", "style": "vivid"
+                }
+
+                print(f"\n🤖🤖🤖🤖Calling DALL-E with prompt: {dalle_prompt_text}")
+                async with aiohttp.ClientSession() as session:
+                    try:
+                        async with session.post(dalle_api_url, headers=dalle_headers, json=dalle_payload) as dalle_response:
+                            dalle_response.raise_for_status()  # Raise an exception for HTTP errors
+                            dalle_data = await dalle_response.json()
+                            if dalle_data.get("data") and len(dalle_data["data"]) > 0:
+                                generated_image_url = dalle_data["data"][0].get("url")
+                                print(f"DALL-E generated image URL: {generated_image_url}")
+                                updates["messages"].append(AIMessage(content=f"Image generated by DALL-E: {generated_image_url}"))
+                            else:
+                                print("Error: DALL-E API did not return image data.")
+                                updates["messages"].append(AIMessage(content="Failed to get image from DALL-E."))
+                    except aiohttp.ClientError as e:
+                        print(f"DALL-E API call error: {e}")
+                        updates["messages"].append(AIMessage(content=f"Error calling DALL-E: {e}"))
+                    except json.JSONDecodeError as e:
+                        print(f"DALL-E API JSON decode error: {e}. Response: {await dalle_response.text()}")
+                        updates["messages"].append(AIMessage(content=f"Error decoding DALL-E response: {e}"))
+                    except Exception as e:
+                        print(f"Unexpected error during DALL-E processing: {e}")
+                        updates["messages"].append(AIMessage(content=f"Unexpected error with DALL-E: {e}"))
+
+            updates.update({
+                "generated_image_url_from_dalle": generated_image_url,
+                "planning_complete": True,
+                "tool_call_required": False,
+                "loop_planning": False,
+            })
+        else:
+            # Check if a tool call was requested
+            if getattr(response, "tool_calls", None):
+                updates.update({
+                    "tool_call_required": True,
+                    "loop_planning": False,
+                })
+            else:
+                updates.update({
+                    "tool_call_required": False,
+                    "loop_planning": True,
+                })
+
+        print("\n🚩🚩 |  end | prompt planing Node \n")
+        return updates
+
+    except Exception as e:
+        print(f"Error in prompt_planning node: {e}")
+        return {
+            "messages": [AIMessage(content="Error in prompt_planning node.")],
+            "next_stage": state.next_stage or "planning"
+        }
+
+async def generate_3d_node(state: GraphProcessingState, config=None):
+    print("\n🚀🚀🚀 |  start | Generate 3D Node ��🚀🚀\n")    
+    # 1. Get the image URL
+    # For now, using a hardcoded URL as requested for testing.
+    # In a real scenario, you might get this from the state:
+    # image_url = state.get("image_url_for_3d")
+    # if not image_url:
+    #     print("No image_url_for_3d found in state.")
+    #     return {"messages": [AIMessage(content="No image URL found for 3D generation.")]}
+
+    hardcoded_image_url = state.generated_image_url_from_dalle
+    print(f"Using hardcoded image_url: {hardcoded_image_url}")
+
+    # 2. Define API endpoint and parameters
+    api_base_url = "https://wishwa-code--trellis-3d-model-generate-dev.modal.run/"
+    params = {
+        "image_url": hardcoded_image_url,
+        "simplify": "0.95",
+        "texture_size": "1024",
+        "sparse_sampling_steps": "12",
+        "sparse_sampling_cfg": "7.5",
+        "slat_sampling_steps": "12",
+        "slat_sampling_cfg": "3",
+        "seed": "42",
+        "output_format": "glb"
+    }
+
+    # Create a directory to store generated models if it doesn't exist
+    output_dir = "generated_3d_models"
+    os.makedirs(output_dir, exist_ok=True)
+
+    # 3. Attempt generation with retries
+    for attempt in range(1, 2):
+        print(f"Attempt {attempt} to call 3D generation API...")
+        try:
+            # Note: The API call can take a long time (1.5 mins in your curl example)
+            # Ensure your HTTP client timeout is sufficient.
+            # httpx default timeout is 5 seconds, which is too short.
+            async with httpx.AsyncClient(timeout=120.0) as client: # Timeout set to 120 seconds
+                response = await client.get(api_base_url, params=params)
+                response.raise_for_status() # Raises an HTTPStatusError for 4XX/5XX responses
+
+            # Successfully got a response
+            if response.status_code == 200:
+                # Assuming the response body is the .glb file content
+                file_name = f"model_{uuid.uuid4()}.glb"
+                file_path = os.path.join(output_dir, file_name)
+
+                with open(file_path, "wb") as f:
+                    f.write(response.content)
+
+                print(f"Success: 3D model saved to {file_path}")
+                return {
+                    "messages": [AIMessage(content=f"3D object generation successful: {file_path}")],
+                    "generate_3d_complete": True,
+                    "three_d_model_path": file_path,
+                    "next_stage": state.get("next_stage") or 'end' # Use .get for safer access
+                }
+            else:
+                # This case might not be reached if raise_for_status() is used effectively,
+                # but good for explicit handling.
+                error_message = f"API returned status {response.status_code}: {response.text}"
+                print(error_message)
+                if attempt == 3: # Last attempt
+                     return {"messages": [AIMessage(content=f"Failed to generate 3D object. Last error: {error_message}")]}
+
+        except httpx.HTTPStatusError as e:
+            error_message = f"HTTP error occurred: {e.response.status_code} - {e.response.text}"
+            print(error_message)
+            if attempt == 3:
+                return {"messages": [AIMessage(content=f"Failed to generate 3D object after 3 attempts. Last HTTP error: {error_message}")]}
+        except httpx.RequestError as e: # Catches network errors, timeout errors etc.
+            error_message = f"Request error occurred: {str(e)}"
+            print(error_message)
+            if attempt == 3:
+                return {"messages": [AIMessage(content=f"Failed to generate 3D object after 3 attempts. Last request error: {error_message}")]}
+        except Exception as e:
+            error_message = f"An unexpected error occurred: {str(e)}"
+            print(error_message)
+            if attempt == 3:
+                return {"messages": [AIMessage(content=f"Failed to generate 3D object after 3 attempts. Last unexpected error: {error_message}")]}
+
+        if attempt < 2:
+            print("Retrying...")
+        else:
+            print("Max retries reached.")
+
+
+    # Failed after retries (this path should ideally be covered by returns in the loop)
+    return {"messages": [AIMessage(content="Failed to generate a valid 3D object after 3 attempts.")]}
+
+def define_workflow() -> CompiledStateGraph:
+    """Defines the workflow graph"""
+    # Initialize the graph
+    workflow = StateGraph(GraphProcessingState)
+
+    # Add nodes
+    workflow.add_node("tools", DebugToolNode(tools))
+    
+    workflow.add_node("guidance_node", guidance_node)
+    workflow.add_node("brainstorming_node", brainstorming_node)
+    workflow.add_node("prompt_planning_node", prompt_planning_node)
+    workflow.add_node("generate_3d_node", generate_3d_node)
+
+    # workflow.add_node("planning_node", planning_node)
+
+    # Edges
+
+    workflow.add_conditional_edges(
+        "guidance_node",
+        guidance_routing,
+            {
+                "brainstorming_node" : "brainstorming_node",
+                "prompt_planning_node" : "prompt_planning_node",
+                "generate_3d_node" : "generate_3d_node"
+            }
+    )
+
+    workflow.add_conditional_edges(
+        "brainstorming_node",
+        tools_condition,
+    )
+
+    workflow.add_conditional_edges(
+        "prompt_planning_node",
+        tools_condition,
+    )
+    workflow.add_edge("tools", "guidance_node")
+    workflow.add_edge("brainstorming_node", "guidance_node")
+    workflow.add_edge("prompt_planning_node", "guidance_node")
+    workflow.add_edge("generate_3d_node", "guidance_node")
+
+
+    # workflow.add_conditional_edges(
+    # "guidance_node",  # The source node
+    # custom_route_after_guidance,  # Your custom condition function
+    #     {
+    #         # "Path name": "Destination node name"
+    #         "execute_tools": "tools",  # If function returns "execute_tools"
+    #         "proceed_to_next_stage": "planning_node" # If function returns "proceed_to_next_stage"
+    #                                                         # Or this could be another router, or END
+    #     }
+    # )
+    # workflow.add_conditional_edges("guidance_node", guidance_routing)
+    # workflow.add_conditional_edges("brainstorming_node", brainstorming_routing)
+
+    # # Set end nodes
+    workflow.set_entry_point("guidance_node")
+    # workflow.set_finish_point("assistant_node")
+    compiled_graph = workflow.compile(checkpointer=memory)
+    try:
+        img_bytes = compiled_graph.get_graph().draw_mermaid_png()
+        with open("graph.png", "wb") as f:
+            f.write(img_bytes)
+        print("Graph image saved as graph.png")
+    except Exception as e:
+        print("Can't print the graph:")
+        print(e)
+
+
+    return compiled_graph
+
+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
+#     }
+
+
+
+
+  # 
+
+
+#   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 guidance_node(state: GraphProcessingState, config=None):
+#     print("\n--- Guidance Node (Debug via print) ---")
+
+#     print(f"Prompt: {state.prompt}")
+#     for message in state.messages:
+#         if isinstance(message, HumanMessage):
+#             print(f"Human: {message.content}")
+#         elif isinstance(message, AIMessage):
+#             if message.content:
+#                 if isinstance(message.content, list):
+#                     texts = [item.get('text', '') for item in message.content if isinstance(item, dict) and 'text' in item]
+#                     if texts:
+#                         print(f"AI: {' '.join(texts)}")
+#                 elif isinstance(message.content, str):
+#                     print(f"AI: {message.content}")
+#         elif isinstance(message, SystemMessage):
+#             print(f"System: {message.content}")
+#         elif isinstance(message, ToolMessage):
+#             print(f"Tool: {message.content}")
+
+#     print(f"Tools Enabled: {state.tools_enabled}")
+#     print(f"Search Enabled: {state.search_enabled}")
+#     print(f"Next Stage: {state.next_stage}")
+
+
+#     print(f"Brainstorming Complete: {state.brainstorming_complete}")
+    
+
+#     guidance_node.count = getattr(guidance_node, 'count', 0) + 1
+#     print('\nGuidance Node called count', guidance_node.count)
+#     print("\n--- End Guidance Node Debug ---")
+
+#     stage_order = ["brainstorming", "planning", "drawing", "product_searching", "purchasing"]
+#     completed = [stage for stage in stage_order if getattr(state, f"{stage}_complete", False)]
+#     incomplete = [stage for stage in stage_order if not getattr(state, f"{stage}_complete", False)]
+
+#     if not incomplete:
+#         print("All stages complete!")
+#         # Handle case where all stages are complete
+#         # You might want to return a message and end, or set proposed_next_stage to a special value
+#         ai_all_complete_msg = AIMessage(content="All DIY project stages are complete!")
+#         return {
+#             "messages": current_messages + [ai_all_complete_msg],
+#             "next_stage": "end_project", # Or None, or a final summary node
+#             "pending_approval_stage": None,
+#         }
+#     else:
+#         # THIS LINE DEFINES THE VARIABLE
+#         proposed_next_stage = incomplete[0]
+
+#     print(f"Proposed next stage: {proposed_next_stage}")
+
+#     status_summary = f"Completed stages: {completed}\nIncomplete stages: {incomplete}"
+
+#     guidance_prompt_text = (
+#         "You are the Guiding Assistant for a DIY project. Your primary responsibility is to determine the next logical step "
+#         "and then **obtain the user's explicit approval** before proceeding.\n\n"
+#         f"CURRENT PROJECT STATUS:\n{status_summary}\n\n"
+#         f"Based on the status, the most logical next stage appears to be: **'{proposed_next_stage}'**.\n\n"
+#         "YOUR TASK:\n"
+#         f"1. Formulate a clear and concise question for the user, asking if they agree to proceed to the **'{proposed_next_stage}'** stage. For example: 'It looks like '{proposed_next_stage}' is next. Shall we proceed with that?' or 'Are you ready to move on to {proposed_next_stage}?'\n"
+#         "2. **You MUST use the 'human_assistance' tool to ask this question.** Do not answer directly. Invoke the tool with your question.\n"
+#         "Example of tool usage (though you don't write this, you *call* the tool):\n"
+#         "Tool Call: human_assistance(query='The next stage is planning. Do you want to proceed with planning?')\n\n"
+#         "Consider the user's most recent message if it provides any preference."
+#     )
+
+#     if state.prompt:
+#         final_prompt = "\n".join([guidance_prompt_text, state.prompt, ASSISTANT_SYSTEM_PROMPT_BASE])
+#     else:
+#         final_prompt = "\n".join([guidance_prompt_text, ASSISTANT_SYSTEM_PROMPT_BASE])
+
+#     prompt = ChatPromptTemplate.from_messages(
+#         [
+#             ("system", final_prompt),
+#             MessagesPlaceholder(variable_name="messages"),
+#         ]
+#     )
+
+#     assistant_model = model.bind_tools([human_assistance])
+
+#     chain = prompt | assistant_model
+
+#     try:
+#         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)
+
+#         # Check for tool calls in the response
+#         if hasattr(response, "tool_calls"):
+#             for tool_call in response.tool_calls:
+#                 tool_name = tool_call['name']
+#                 if tool_name == "human_assistance":
+#                     query = tool_call['args']['query']
+#                     print(f"Human input needed: {query}")
+#                     # Handle human assistance tool call
+#                     # You can pause execution and wait for user input here
+
+#         return {
+#             "messages": [response],
+#             "next_stage": incomplete[0] if incomplete else "brainstorming"
+#         }
+#     except Exception as e:
+#         print(f"Error in guidance node: {e}")
+#         return {
+#             "messages": [AIMessage(content="Error in guidance node.")],
+#             "next_stage": "brainstorming"
+#         }

greeting_prompt.txt

@@ -0,0 +1,2 @@
+Hi! I am හොදබාස්, Hodabas your friendly DIY helper.
+Looking to build something awesome today? Let's find the right tools and materials together!

logging-config.json

@@ -0,0 +1,35 @@
+{
+    "version": 1,
+    "disable_existing_loggers": false,
+    "formatters": {
+        "verbose": {
+            "format": "%(asctime)s:%(name)s:%(levelname)s: %(message)s",
+            "datefmt": "%Y-%m-%d %H:%M:%S"
+        }
+    },
+    "handlers": {
+        "console": {
+            "class": "logging.StreamHandler",
+            "level": "INFO",
+            "formatter": "verbose"
+        },
+        "file": {
+            "class": "logging.FileHandler",
+            "filename": "app.log",
+            "level": "INFO",
+            "formatter": "verbose",
+            "encoding": "utf-8"
+        }
+    },
+    "loggers": {
+        "httpx": { 
+            "level": "WARNING", 
+            "handlers": ["console"],
+            "propagate": false 
+        }
+    },
+    "root": {
+        "level": "INFO",
+        "handlers": ["console", "file"]
+    }
+}

requirements.txt

@@ -0,0 +1,21 @@
+Pillow
+gradio==5.33.0
+langchain
+langchain-community
+langchain-core
+langchain-anthropic
+langchain-google-genai
+langchain-huggingface
+langchain-groq
+langchain-tavily
+langchain-chroma
+langgraph
+huggingface_hub
+python-dotenv
+graphviz
+trafilatura==2.0.0
+pydantic==2.10.6
+langchain-community
+langchain_openai
+mistralai
+langchain-mistralai