Upload folder using huggingface_hub

app.py

@@ -1,7 +1,9 @@
+import json
 import os
 import random
 import asyncio
 import logging
+import traceback
 import uuid
 from html import escape
 import gradio as gr
@@ -107,11 +109,30 @@ def chat(message, history, thread_id):
     return response["messages"][-1].content
 
 
-def add_node_to_tree(node_tree : list[str], node : str) -> list[str]:
-    node_tree[-1] = node
-    node_tree.append("<span class='spinner'>⏳</span>")
+def add_node_to_tree(
+    node_tree: list[str], node_label: str, tooltip: str = "no arguments to show"
+) -> list[str]:
+    if tooltip:
+        tooltip = escape(tooltip).replace("'", "&apos;")
+        node_with_tooltip = (
+            f"<span class='node-label' title='{tooltip}'>{node_label}</span>"
+        )
+    else:
+        node_with_tooltip = node_label
+    node_tree[-1] = node_with_tooltip
+    node_tree.append("<span class='spinner'>&nbsp;</span>")
     return node_tree
 
+
+def get_args_for_toolcall(tool_calls_buffer: dict, tool_call_id: str):
+    return (
+        tool_calls_buffer[tool_call_id]["args_str"]
+        if tool_call_id in tool_calls_buffer
+        and "args_str" in tool_calls_buffer[tool_call_id]
+        else ""
+    )
+
+
 async def chat_streaming(message, history, thread_id):
     state = {"messages": (history or []) + [{"role": "user", "content": message}]}
     config = {"configurable": {"thread_id": thread_id}}
@@ -121,36 +142,43 @@ async def chat_streaming(message, history, thread_id):
     MAX_CONTENT = 500
 
     try:
-        tool_calls = []
-        node_tree = ["__start__","<span class='spinner'>⏳</span>"]
+        node_tree = ["🚩", "<span class='spinner'>&nbsp;</span>"]
+
+        tool_calls_buffer = {}
+
         async for msg, metadata in graph.astream(
             state, config=config, stream_mode="messages"
         ):
             node = metadata.get("langgraph_node", "?")
             name = getattr(msg, "name", "-")
-            if(not isinstance(msg, ToolMessage)):
+            if not isinstance(msg, ToolMessage):
                 node_icon = "🧠"
             else:
                 node_icon = "⚙️"
             node_label = f"node:{node}"
-            tool_label =f"{name or ''}"
-            if(tool_label):
+            tool_label = f"{name or ''}"
+            if tool_label:
                 node_label = node_label + f":{tool_label}"
             label = f"{node_icon} {node_label}"
+            tooltip = ""
+            if isinstance(msg, ToolMessage):
+                tooltip = get_args_for_toolcall(tool_calls_buffer, msg.tool_call_id)
+                logger.info("tooltip = ", tooltip)
+
             # checking for -2 last but one. since last entry is always a spinner
-            if(node_tree[-2] != label):
-                add_node_to_tree(node_tree, label)
+            if node_tree[-2] != label:
+                add_node_to_tree(node_tree, label, tooltip)
             full: str = escape(msg.content)
             truncated = (full[:MAX_CONTENT] + "…") if len(full) > MAX_CONTENT else full
 
             def generate_processing_message():
                 return (
-                f"<div class='thinking-bubble'><em>🤔{random.choice(thinking_verbs)} ...</em></div>"
-                f"<div style='opacity: 0.1' title='{full}'>"
-                f"<span>{node}:{name or ''}:</span>"
-                f"<strong>Looking for : [{message}]</strong> {truncated or '...'}"
-                f"</div>"
-            )
+                    f"<div class='thinking-bubble'><em>🤔{random.choice(thinking_verbs)} ...</em></div>"
+                    f"<div style='opacity: 0.1' title='{full}'>"
+                    f"<span>{node}:{name or ''}:</span>"
+                    f"<strong>Looking for : [{message}]</strong> {truncated or '...'}"
+                    f"</div>"
+                )
 
             if (
                 not isinstance(msg, ToolMessage)
@@ -160,13 +188,17 @@ async def chat_streaming(message, history, thread_id):
                 logger.info("msg = %s", msg)
             if isinstance(msg, ToolMessage):
                 logger.debug("tool message = %s", msg)
+
                 html = (
-                    f"<div class='thinking-bubble'><em>🤔{name} tool: {random.choice(thinking_verbs)} ...</em></div>"
+                    f"<div class='thinking-bubble'><em>🤔 {msg.name} tool: {random.choice(thinking_verbs)} ...</em></div>"
                     f"<div style='opacity: 0.5'>"
-                    f"<strong>Looking for : [{message}]</strong> {truncated or '...'}"
+                    f"<strong>Looking for : [{message}]</strong><br>"
+                    f"<strong>Tool Args:</strong> {tooltip or '(no args)'}<br>"
+                    f"{truncated or '...'}"
                     f"</div>"
                 )
-                yield f"### { " → ".join(node_tree)}\n{html}"
+                yield f"### { ' → '.join(node_tree)}\n{html}"
+                await asyncio.sleep(5)
             elif isinstance(msg, AIMessageChunk):
                 if not msg.content:
                     # logger.warning("*** No Message Chunk!")
@@ -174,11 +206,30 @@ async def chat_streaming(message, history, thread_id):
                 else:
                     streamed_response += msg.content
                     yield f"### { " → ".join(node_tree)}\n{streamed_response}"
-                if(msg.tool_calls):
-                    tool_calls.append(msg.tool_calls)
-            elif isinstance(msg, AIMessage):                    
-                if(msg.tool_calls):
-                    tool_calls.append(msg.tool_calls)
+
+                if msg.tool_call_chunks:
+                    for tool_call_chunk in msg.tool_call_chunks:
+                        print("*** tool_call_chunk = ", tool_call_chunk)
+                        if tool_call_chunk["id"] is not None:
+                            tool_call_id = tool_call_chunk["id"]
+
+                        if tool_call_id not in tool_calls_buffer:
+                            tool_calls_buffer[tool_call_id] = {
+                                "name": "",
+                                "args_str": "",
+                                "id": tool_call_id,
+                                "type": "tool_call",
+                            }
+
+                        # Accumulate tool call name and arguments
+                        if tool_call_chunk["name"] is not None:
+                            tool_calls_buffer[tool_call_id]["name"] += tool_call_chunk[
+                                "name"
+                            ]
+                        if tool_call_chunk["args"] is not None:
+                            tool_calls_buffer[tool_call_id][
+                                "args_str"
+                            ] += tool_call_chunk["args"]
             else:
                 logger.debug("message = ", type(msg), msg.content[:100])
                 full: str = escape(msg.content)
@@ -192,11 +243,37 @@ async def chat_streaming(message, history, thread_id):
                     f"</div>"
                 )
                 yield f"### { " → ".join(node_tree)}\n{html}"
+                if getattr(msg, "tool_calls", []):
+                    logger.info("ELSE::tool_calls = %s", msg.tool_calls)
 
         node_tree[-1] = "✅"
-        yield f"### { " → ".join(node_tree)}\n{streamed_response}"
+
+        yield (
+            f"### {' → '.join(node_tree)}"
+            f"\n{streamed_response}"
+        )
+
+        print("************************************")
+        # Now, you can process the complete tool calls from the buffer
+        for tool_call_id, accumulated_tool_call in tool_calls_buffer.items():
+            # Attempt to parse arguments only if the 'args_str' isn't empty
+            if accumulated_tool_call["args_str"]:
+                try:
+                    parsed_args = json.loads(accumulated_tool_call["args_str"])
+                    print(f"Tool Name: {accumulated_tool_call['name']}")
+                    print(f"Tool Arguments: {parsed_args}")
+                except json.JSONDecodeError:
+                    print(
+                        f"Partial arguments for tool {accumulated_tool_call['name']}: {accumulated_tool_call['args_str']}"
+                    )
     except Exception as e:
-        yield f"Error processing request {str(e)}"
+        logger.error("❌❌❌ Error processing request: %s", e)
+        traceback.print_exc()
+        yield (
+            f"❌❌❌ Error processing request {str(e)}\n"
+            "here is what I got so far ...\n"
+            f"### { " → ".join(node_tree)}\n{streamed_response}"
+        )
 
 
 # UI Elements
@@ -281,6 +358,12 @@ chatInterface = gr.ChatInterface(
   50% { opacity: 1; }
   100% { opacity: 0.3; }
 }
+
+.node-label {
+  cursor: help;
+  border-bottom: 1px dotted #aaa;
+}
+
 """,
 )