Update app.py

app.py

@@ -55,94 +55,91 @@ graph.add_edge("agent", END)
 compiled_graph = graph.compile()
 
 def respond_to_input(user_input: str) -> str:
-    """
-    Wrap compiled_graph.invoke(…) (and the “second pass”) in a try/except
-    so that if the agent ever returns something unparsable (a plain str),
-    we catch it and avoid the `'str' object has no attribute 'items'` error.
-    """
-
-    # A) Build a SystemMessage that forces the model to emit bare JSON if it calls a tool:
+    # 1) Build a SystemMessage that insists on bare JSON if calling a tool
     system_msg = SystemMessage(
         content=(
             "You are an assistant with access to exactly these tools:\n"
             "  1) web_search(query:str)\n"
             "  2) parse_excel(path:str,sheet_name:str)\n"
             "  3) ocr_image(path:str)\n\n"
-            "⚠️ **IMPORTANT** ⚠️: If (and only if) you need to call a tool, "
-            "output exactly one JSON object and nothing else. For example:\n"
+            "⚠️ **IMPORTANT** ⚠️: If (and only if) you need to call a tool, output exactly one\n"
+            "JSON object (no extra text). For example:\n"
             "```json\n"
             '{"tool":"web_search","query":"Mercedes Sosa albums 2000-2009"}\n'
             "```\n"
-            "That JSON must start at the very first character of your response and end at the very last character—"
-            "no quotes, no code fences, and no extra explanation.\n\n"
+            "That JSON must start at the very first character of your response and end at the last\n"
+            "character—no quotes, no code fences, and no explanation.\n\n"
             "If you do NOT need any tool, simply reply with your final answer as plain text."
         )
     )
 
-    # B) Initialize state with just that SystemMessage. We'll pass user_input separately below:
-    initial_state = { "messages": [system_msg] }
+    # 2) Initialize state with just that SystemMessage
+    initial_state = {"messages": [system_msg]}
 
+    # 3) --- FIRST PASS: just invoke the graph and see what it returns ---
     try:
-        # C) First pass: invoke the graph with the user’s question:
-        final_state = compiled_graph.invoke(initial_state, user_input)
-
-        # D) Log every AIMessage for debugging (optional—remove in production):
-        print("===== AGENT MESSAGES (First Pass) =====")
-        for i, msg in enumerate(final_state["messages"]):
+        first_pass = compiled_graph.invoke(initial_state, user_input)
+    except Exception as e:
+        # If the error happens here, we log it plus any partial messages
+        print("‼️ ERROR during first invoke:", repr(e))
+        # If there is some state, print it for debugging:
+        try:
+            partial = first_pass["messages"]
+        except Exception:
+            partial = None
+        print("Partial state messages (if any):", partial)
+        # Return empty string so the loop can continue
+        return ""
+
+    # 4) If we reach here, first_pass succeeded. Log every AIMessage so we can see exactly
+    print("===== AGENT MESSAGES (First Pass) =====")
+    for idx, msg in enumerate(first_pass["messages"]):
+        if isinstance(msg, AIMessage):
+            # Print out raw content to see if it’s JSON or plain text
+            print(f"[AIMessage #{idx}]: {repr(msg.content)}")
+    print("=========================================")
+
+    # 5) Find the last AIMessage content (might be JSON or might be plain text)
+    last_msg = None
+    for msg in reversed(first_pass["messages"]):
+        if isinstance(msg, AIMessage):
+            last_msg = msg.content
+            break
+
+    # 6) Attempt to parse last_msg as a JSON dict for a tool call
+    tool_dict = parse_tool_json(last_msg or "")
+    if tool_dict:
+        # 7) If valid JSON, run the tool and do a second pass
+        print(">> Parsed tool call:", tool_dict)
+        tool_result = tool_node.run(tool_dict)
+        print(f">> Tool '{tool_dict['tool']}' returned: {repr(tool_result)}")
+
+        continuation_state = {
+            "messages": [
+                *first_pass["messages"],
+                AIMessage(content=tool_result)
+            ]
+        }
+        try:
+            second_pass = compiled_graph.invoke(continuation_state, "")
+        except Exception as e2:
+            print("‼️ ERROR during second invoke:", repr(e2))
+            return ""
+        # 8) Log second‐pass AIMessages
+        print("===== AGENT MESSAGES (Second Pass) =====")
+        for idx, msg in enumerate(second_pass["messages"]):
             if isinstance(msg, AIMessage):
-                print(f"[AIMessage #{i}]: {repr(msg.content)}")
+                print(f"[AIMessage2 #{idx}]: {repr(msg.content)}")
         print("=========================================")
 
-        # E) Find the very last AIMessage the agent produced:
-        last_msg = None
-        for msg in reversed(final_state["messages"]):
+        # 9) Return the final AIMessage from second_pass
+        for msg in reversed(second_pass["messages"]):
             if isinstance(msg, AIMessage):
-                last_msg = msg.content
-                break
-
-        # F) Try to parse that last_msg as a tool‐call JSON:
-        tool_dict = parse_tool_json(last_msg or "")
-        if tool_dict:
-            # G) If valid JSON, run the tool:
-            print(">> Parsed tool call:", tool_dict)
-            tool_result = tool_node.run(tool_dict)
-
-            # H) Log output of the tool (optional):
-            print(f">> Tool '{tool_dict['tool']}' returned: {repr(tool_result)}")
-
-            # I) Second pass: feed the tool’s result back into the graph,
-            #    with an empty user_input because we’re continuing the same turn.
-            continuation_state = {
-                "messages": [
-                    *final_state["messages"],
-                    AIMessage(content=tool_result)
-                ]
-            }
-            second_pass = compiled_graph.invoke(continuation_state, "")
-
-            # J) Log every AIMessage from the second pass (optional):
-            print("===== AGENT MESSAGES (Second Pass) =====")
-            for i, msg in enumerate(second_pass["messages"]):
-                if isinstance(msg, AIMessage):
-                    print(f"[AIMessage2 #{i}]: {repr(msg.content)}")
-            print("=========================================")
-
-            # K) Return the last AIMessage from the second pass as the final answer:
-            for msg in reversed(second_pass["messages"]):
-                if isinstance(msg, AIMessage):
-                    return msg.content or ""
-            return ""
-
-        else:
-            # L) If it wasn’t valid JSON, just treat last_msg as plain‐text final answer:
-            return last_msg or ""
-
-    except Exception as e:
-        # M) If *any* part of the above raises (e.g. because the LLM returned a string
-        #    that the routing layer tried to treat as a dict), we catch it here:
-        print(f"‼️ respond_to_input error: {repr(e)}")
-        return ""  # or return a default fallback string if you prefer
-
+                return msg.content or ""
+        return ""
+    else:
+        # 10) No valid JSON, return last_msg as plain text
+        return last_msg or ""
 
 class BasicAgent:
     def __init__(self):