feat: Add interrupt handling and YesNoDecision class for user queries

- Implemented `handle_interrupt` function to manage user approval for interrupted searches in `app.py`.
- Introduced `YesNoDecision` class with a method to parse string inputs into decision instances in `nodes.py`.
- Updated the `search_help` function to utilize the new decision structure for user permissions.

app.py

@@ -11,13 +11,20 @@ import chainlit as cl
 import httpx
 import nest_asyncio
 from dotenv import load_dotenv
+from langchain.callbacks.base import BaseCallbackHandler
 from langchain_core.documents import Document
 from langchain_core.runnables import Runnable
 from langgraph.checkpoint.memory import MemorySaver
+from langgraph.types import Command
 
 from pstuts_rag.configuration import Configuration
 from pstuts_rag.datastore import Datastore
-from pstuts_rag.nodes import FinalAnswer, TutorialState, initialize
+from pstuts_rag.nodes import (
+    FinalAnswer,
+    TutorialState,
+    initialize,
+    YesNoDecision,
+)
 from pstuts_rag.utils import get_unique
 
 # Track the single active session
@@ -203,9 +210,6 @@ async def format_url_reference(url_ref):
     )
 
 
-from langchain.callbacks.base import BaseCallbackHandler
-
-
 class ChainlitCallbackHandler(BaseCallbackHandler):
     """
     Custom callback handler for Chainlit to visualize the execution of LangChain chains/graphs.
@@ -293,6 +297,42 @@ class ChainlitCallbackHandler(BaseCallbackHandler):
 # TODO Add buttons with pregenerated queries
 
 
+async def handle_interrupt(query: str) -> YesNoDecision:
+
+    try:
+        user_input = await cl.AskActionMessage(
+            content="Search has been interrupted. Do you approve query: '%s' to be sent to Adobe Help?"
+            % query,
+            timeout=30,
+            raise_on_timeout=True,
+            actions=[
+                cl.Action(
+                    name="approve",
+                    payload={"value": "yes"},
+                    label="✅ Approve",
+                ),
+                cl.Action(
+                    name="cancel",
+                    payload={"value": "cancel"},
+                    label="❌ Cancel web search",
+                ),
+            ],
+        ).send()
+        if user_input and user_input.get("payload").get("value") == "yes":
+            return YesNoDecision(decision="yes")
+        else:
+            return YesNoDecision(decision="no")
+
+    except TimeoutError:
+        await cl.Message(
+            "Timeout: No response from user. Canceling search."
+        ).send()
+        return YesNoDecision(decision="no")
+
+
+from pstuts_rag.nodes import YesNoDecision
+
+
 @cl.on_message
 async def message_handler(input_message: cl.Message):
     """
@@ -329,11 +369,25 @@ async def message_handler(input_message: cl.Message):
     config = configuration.to_runnable_config()
     config["callbacks"] = [ChainlitCallbackHandler()]
 
-    response = cast(
-        TutorialState,
-        await ai_graph.ainvoke({"query": input_message.content}, config),
+    raw_response = await ai_graph.ainvoke(
+        {"query": input_message.content}, config
     )
 
+    if "__interrupt__" in raw_response:
+        logging.warning("*** INTERRUPT ***")
+
+        logging.info(raw_response["__interrupt__"])
+
+        answer: YesNoDecision = await handle_interrupt(
+            raw_response["__interrupt__"][-1].value["query"]
+        )
+
+        raw_response = await ai_graph.ainvoke(
+            Command(resume=answer.decision), config
+        )
+
+    response = cast(TutorialState, raw_response)
+
     for msg in response["messages"]:
         if isinstance(msg, FinalAnswer):
             # Stream the final answer token-by-token for a typing effect
@@ -346,10 +400,18 @@ async def message_handler(input_message: cl.Message):
             if final_msg:
                 await final_msg.update()
 
+    await cl.Message(
+        content=f"Formatting {len(response['video_references'])} video references."
+    ).send()
+
     # Send all unique video references as separate messages
     for v in get_unique(response["video_references"]):
         await format_video_reference(v).send()
 
+    await cl.Message(
+        content=f"Formatting {len(response['url_references'])} website references."
+    ).send()
+
     # Send all unique URL references as separate messages (with screenshots if available)
     url_reference_tasks = [
         format_url_reference(u) for u in get_unique(response["url_references"])

pstuts_rag/pstuts_rag/nodes.py

@@ -185,10 +185,10 @@ async def search_help(state: TutorialState, config: RunnableConfig):
         logging.info("search_help: asking permission")
 
         response = interrupt(
-            (
-                f"Do you allow Internet search for query '{query}'?"
-                "Answer 'yes' will perform the search, any other answer will skip it."
-            )
+            {
+                "message": "Do you allow Internet search for this query?",
+                "query": query,
+            }
         )
 
         logging.info(f"Permission response '{response}'")
@@ -306,6 +306,24 @@ class YesNoDecision(BaseModel):
 
     decision: Literal["yes", "no"] = Field(description="Yes or no decision.")
 
+    @classmethod
+    def from_string(cls, value: str) -> "YesNoDecision":
+        """Parse a string and return a YesNoDecision instance, mapping common affirmatives to 'yes', others to 'no'."""
+        affirmatives = {
+            "yes",
+            "y",
+            "true",
+            "ok",
+            "okay",
+            "sure",
+            "1",
+            "fine",
+            "alright",
+        }
+        if value.strip().lower() in affirmatives:
+            return cls(decision="yes")
+        return cls(decision="no")
+
 
 class URLReference(BaseModel):
     """Model for URL reference with summary.