refactor: enhance webhook processing and add health check endpoint

app.py

@@ -70,10 +70,10 @@ RECOGNIZED_TAGS = {
 
 
 class WebhookEvent(BaseModel):
-    event: Dict[str, str]
-    comment: Dict[str, Any]
-    discussion: Dict[str, Any]
-    repo: Dict[str, str]
+    event: Dict[str, str]       # Contains action and scope information
+    comment: Dict[str, Any]     # Comment content and metadata
+    discussion: Dict[str, Any]  # Discussion information
+    repo: Dict[str, str]        # Repository details
 
 
 app = FastAPI(title="HF Tagging Bot")
@@ -160,304 +160,457 @@ def extract_tags_from_text(text: str) -> List[str]:
     return valid_tags
 
 
+# async def process_webhook_comment(webhook_data: Dict[str, Any]):
+#     """Process webhook to detect and add tags"""
+#     print("🏷️ Starting process_webhook_comment...")
+
+#     try:
+#         comment_content = webhook_data["comment"]["content"]
+#         discussion_title = webhook_data["discussion"]["title"]
+#         repo_name = webhook_data["repo"]["name"]
+#         discussion_num = webhook_data["discussion"]["num"]
+#         # Author is an object with "id" field
+#         comment_author = webhook_data["comment"]["author"].get("id", "unknown")
+
+#         print(f"📝 Comment content: {comment_content}")
+#         print(f"📰 Discussion title: {discussion_title}")
+#         print(f"📦 Repository: {repo_name}")
+
+#         # Extract potential tags from the comment and discussion title
+#         comment_tags = extract_tags_from_text(comment_content)
+#         title_tags = extract_tags_from_text(discussion_title)
+#         all_tags = list(set(comment_tags + title_tags))
+
+#         print(f"🔍 Comment tags found: {comment_tags}")
+#         print(f"🔍 Title tags found: {title_tags}")
+#         print(f"🏷️ All unique tags: {all_tags}")
+
+#         result_messages = []
+
+#         if not all_tags:
+#             msg = "No recognizable tags found in the discussion."
+#             print(f"❌ {msg}")
+#             result_messages.append(msg)
+#         else:
+#             print("🤖 Getting agent instance...")
+#             agent = await get_agent()
+#             if not agent:
+#                 msg = "Error: Agent not configured (missing HF_TOKEN)"
+#                 print(f"❌ {msg}")
+#                 result_messages.append(msg)
+#             else:
+#                 print("✅ Agent instance obtained successfully")
+
+#                 # Process all tags in a single conversation with the agent
+#                 try:
+#                     # Create a comprehensive prompt for the agent
+#                     user_prompt = f"""
+# I need to add the following tags to the repository '{repo_name}': {", ".join(all_tags)}
+
+# For each tag, please:
+# 1. Check if the tag already exists on the repository using get_current_tags
+# 2. If the tag doesn't exist, add it using add_new_tag
+# 3. Provide a summary of what was done for each tag
+
+# Please process all {len(all_tags)} tags: {", ".join(all_tags)}
+# """
+
+#                     print("💬 Sending comprehensive prompt to agent...")
+#                     print(f"📝 Prompt: {user_prompt}")
+
+#                     # Let the agent handle the entire conversation
+#                     conversation_result = []
+
+#                     try:
+#                         async for item in agent.run(user_prompt):
+#                             # The agent yields different types of items
+#                             item_str = str(item)
+#                             conversation_result.append(item_str)
+
+#                             # Log important events
+#                             if (
+#                                 "tool_call" in item_str.lower()
+#                                 or "function" in item_str.lower()
+#                             ):
+#                                 print(f"🔧 Agent using tools: {item_str[:200]}...")
+#                             elif "content" in item_str and len(item_str) < 500:
+#                                 print(f"💭 Agent response: {item_str}")
+
+#                         # Extract the final response from the conversation
+#                         full_response = " ".join(conversation_result)
+#                         print(f"📋 Agent conversation completed successfully")
+
+#                         # Try to extract meaningful results for each tag
+#                         for tag in all_tags:
+#                             tag_mentioned = tag.lower() in full_response.lower()
+
+#                             if (
+#                                 "already exists" in full_response.lower()
+#                                 and tag_mentioned
+#                             ):
+#                                 msg = f"Tag '{tag}': Already exists"
+#                             elif (
+#                                 "pr" in full_response.lower()
+#                                 or "pull request" in full_response.lower()
+#                             ):
+#                                 if tag_mentioned:
+#                                     msg = f"Tag '{tag}': PR created successfully"
+#                                 else:
+#                                     msg = (
+#                                         f"Tag '{tag}': Processed "
+#                                         "(PR may have been created)"
+#                                     )
+#                             elif "success" in full_response.lower() and tag_mentioned:
+#                                 msg = f"Tag '{tag}': Successfully processed"
+#                             elif "error" in full_response.lower() and tag_mentioned:
+#                                 msg = f"Tag '{tag}': Error during processing"
+#                             else:
+#                                 msg = f"Tag '{tag}': Processed by agent"
+
+#                             print(f"✅ Result for tag '{tag}': {msg}")
+#                             result_messages.append(msg)
+
+#                     except Exception as agent_error:
+#                         print(f"⚠️ Agent streaming failed: {str(agent_error)}")
+#                         print("🔄 Falling back to direct MCP tool calls...")
+
+#                         # Import the MCP server functions directly as fallback
+#                         try:
+#                             import sys
+#                             import importlib.util
+
+#                             # Load the MCP server module
+#                             spec = importlib.util.spec_from_file_location(
+#                                 "mcp_server", "./mcp_server.py"
+#                             )
+#                             mcp_module = importlib.util.module_from_spec(spec) # type: ignore
+#                             spec.loader.exec_module(mcp_module) # type: ignore
+
+#                             # Use the MCP tools directly for each tag
+#                             for tag in all_tags:
+#                                 try:
+#                                     print(
+#                                         f"🔧 Directly calling get_current_tags for '{tag}'"
+#                                     )
+#                                     current_tags_result = mcp_module.get_current_tags(
+#                                         repo_name
+#                                     )
+#                                     print(
+#                                         f"📄 Current tags result: {current_tags_result}"
+#                                     )
+
+#                                     # Parse the JSON result
+#                                     import json
+
+#                                     tags_data = json.loads(current_tags_result)
+
+#                                     if tags_data.get("status") == "success":
+#                                         current_tags = tags_data.get("current_tags", [])
+#                                         if tag in current_tags:
+#                                             msg = f"Tag '{tag}': Already exists"
+#                                             print(f"✅ {msg}")
+#                                         else:
+#                                             print(
+#                                                 f"🔧 Directly calling add_new_tag for '{tag}'"
+#                                             )
+#                                             add_result = mcp_module.add_new_tag(
+#                                                 repo_name, tag
+#                                             )
+#                                             print(f"📄 Add tag result: {add_result}")
+
+#                                             add_data = json.loads(add_result)
+#                                             if add_data.get("status") == "success":
+#                                                 pr_url = add_data.get("pr_url", "")
+#                                                 msg = f"Tag '{tag}': PR created - {pr_url}"
+#                                             elif (
+#                                                 add_data.get("status")
+#                                                 == "already_exists"
+#                                             ):
+#                                                 msg = f"Tag '{tag}': Already exists"
+#                                             else:
+#                                                 msg = f"Tag '{tag}': {add_data.get('message', 'Processed')}"
+#                                             print(f"✅ {msg}")
+#                                     else:
+#                                         error_msg = tags_data.get(
+#                                             "error", "Unknown error"
+#                                         )
+#                                         msg = f"Tag '{tag}': Error - {error_msg}"
+#                                         print(f"❌ {msg}")
+
+#                                     result_messages.append(msg)
+
+#                                 except Exception as direct_error:
+#                                     error_msg = f"Tag '{tag}': Direct call error - {str(direct_error)}"
+#                                     print(f"❌ {error_msg}")
+#                                     result_messages.append(error_msg)
+
+#                         except Exception as fallback_error:
+#                             error_msg = (
+#                                 f"Fallback approach failed: {str(fallback_error)}"
+#                             )
+#                             print(f"❌ {error_msg}")
+#                             result_messages.append(error_msg)
+
+#                 except Exception as e:
+#                     error_msg = f"Error during agent processing: {str(e)}"
+#                     print(f"❌ {error_msg}")
+#                     result_messages.append(error_msg)
+
+#         # Store the interaction
+#         base_url = "https://huggingface.co"
+#         discussion_url = f"{base_url}/{repo_name}/discussions/{discussion_num}"
+
+#         interaction = {
+#             "timestamp": datetime.now().isoformat(),
+#             "repo": repo_name,
+#             "discussion_title": discussion_title,
+#             "discussion_num": discussion_num,
+#             "discussion_url": discussion_url,
+#             "original_comment": comment_content,
+#             "comment_author": comment_author,
+#             "detected_tags": all_tags,
+#             "results": result_messages,
+#         }
+
+#         tag_operations_store.append(interaction)
+#         final_result = " | ".join(result_messages)
+#         print(f"💾 Stored interaction and returning result: {final_result}")
+#         return final_result
+
+#     except Exception as e:
+#         error_msg = f"❌ Fatal error in process_webhook_comment: {str(e)}"
+#         print(error_msg)
+#         return error_msg
+
+
+@app.post("/webhook")
+async def webhook_handler(request: Request, background_tasks: BackgroundTasks):
+    """
+    Handle incoming webhooks from Hugging Face Hub
+    Following the pattern from: https://raw.githubusercontent.com/huggingface/hub-docs/refs/heads/main/docs/hub/webhooks-guide-discussion-bot.md
+    """
+    print("🔔 Webhook received!")
+
+    # Step 1: Validate webhook secret (security)
+    webhook_secret = request.headers.get("X-Webhook-Secret")
+    if webhook_secret != WEBHOOK_SECRET:
+        print("❌ Invalid webhook secret")
+        return {"error": "Invalid webhook secret"}, 400
+
+    # Step 2: Parse webhook data
+    try:
+        webhook_data = await request.json()
+        print(f"📥 Webhook data: {json.dumps(webhook_data, indent=2)}")
+    except Exception as e:
+        print(f"❌ Error parsing webhook data: {str(e)}")
+        return {"error": "invalid JSON"}, 400
+
+    # Step 3: Validate event structure
+    event = webhook_data.get("event", {})
+    if not event:
+        print("❌ No event data in webhook")
+        return {"error": "missing event data"}, 400
+    
+    scope = event.get("scope")
+    action = event.get("action")
+
+    print(f"🔍 Event details - scope: {scope}, action: {action}")
+
+    # Step 4: Check if this is a discussion comment creation
+    # Following the webhook guide pattern:
+    if (
+        action == "create" and
+        scope == "discussion.comment"
+    ):
+        print("✅ Valid discussion comment creation event")
+        
+        # Process in background to return quickly to Hub
+        background_tasks.add_task(process_webhook_comment, webhook_data)
+        
+        return {
+            "status": "accepted",
+            "message": "Comment processing started",
+            "timestamp": datetime.now().isoformat()
+        }
+    else:
+        print(f"ℹ️ Ignoring event: action={event.get('action')}, scope={event.get('scope')}")
+        return {
+            "status": "ignored",
+            "reason": "Not a discussion comment creation"
+        }    
+
+
 async def process_webhook_comment(webhook_data: Dict[str, Any]):
-    """Process webhook to detect and add tags"""
+    """
+    Process webhook comment to detect and add tags
+    Integrates with our MCP client for Hub interactions
+    """
     print("🏷️ Starting process_webhook_comment...")
-
+    
     try:
+        # Extract comment and repository information
         comment_content = webhook_data["comment"]["content"]
         discussion_title = webhook_data["discussion"]["title"]
         repo_name = webhook_data["repo"]["name"]
         discussion_num = webhook_data["discussion"]["num"]
-        # Author is an object with "id" field
         comment_author = webhook_data["comment"]["author"].get("id", "unknown")
-
-        print(f"📝 Comment content: {comment_content}")
-        print(f"📰 Discussion title: {discussion_title}")
+        
+        print(f"📝 Comment from {comment_author}: {comment_content}")
+        print(f"📰 Discussion: {discussion_title}")
         print(f"📦 Repository: {repo_name}")
+    except Exception as e:
+        print(f"❌ Error parsing webhook data: {str(e)}")
+        return {"error": "invalid JSON"}, 400
 
-        # Extract potential tags from the comment and discussion title
-        comment_tags = extract_tags_from_text(comment_content)
-        title_tags = extract_tags_from_text(discussion_title)
-        all_tags = list(set(comment_tags + title_tags))
-
-        print(f"🔍 Comment tags found: {comment_tags}")
-        print(f"🔍 Title tags found: {title_tags}")
-        print(f"🏷️ All unique tags: {all_tags}")
-
-        result_messages = []
-
-        if not all_tags:
-            msg = "No recognizable tags found in the discussion."
-            print(f"❌ {msg}")
-            result_messages.append(msg)
-        else:
-            print("🤖 Getting agent instance...")
-            agent = await get_agent()
-            if not agent:
-                msg = "Error: Agent not configured (missing HF_TOKEN)"
-                print(f"❌ {msg}")
-                result_messages.append(msg)
-            else:
-                print("✅ Agent instance obtained successfully")
-
-                # Process all tags in a single conversation with the agent
-                try:
-                    # Create a comprehensive prompt for the agent
-                    user_prompt = f"""
-I need to add the following tags to the repository '{repo_name}': {", ".join(all_tags)}
-
-For each tag, please:
-1. Check if the tag already exists on the repository using get_current_tags
-2. If the tag doesn't exist, add it using add_new_tag
-3. Provide a summary of what was done for each tag
-
-Please process all {len(all_tags)} tags: {", ".join(all_tags)}
-"""
-
-                    print("💬 Sending comprehensive prompt to agent...")
-                    print(f"📝 Prompt: {user_prompt}")
-
-                    # Let the agent handle the entire conversation
-                    conversation_result = []
-
-                    try:
-                        async for item in agent.run(user_prompt):
-                            # The agent yields different types of items
-                            item_str = str(item)
-                            conversation_result.append(item_str)
-
-                            # Log important events
-                            if (
-                                "tool_call" in item_str.lower()
-                                or "function" in item_str.lower()
-                            ):
-                                print(f"🔧 Agent using tools: {item_str[:200]}...")
-                            elif "content" in item_str and len(item_str) < 500:
-                                print(f"💭 Agent response: {item_str}")
-
-                        # Extract the final response from the conversation
-                        full_response = " ".join(conversation_result)
-                        print(f"📋 Agent conversation completed successfully")
-
-                        # Try to extract meaningful results for each tag
-                        for tag in all_tags:
-                            tag_mentioned = tag.lower() in full_response.lower()
-
-                            if (
-                                "already exists" in full_response.lower()
-                                and tag_mentioned
-                            ):
-                                msg = f"Tag '{tag}': Already exists"
-                            elif (
-                                "pr" in full_response.lower()
-                                or "pull request" in full_response.lower()
-                            ):
-                                if tag_mentioned:
-                                    msg = f"Tag '{tag}': PR created successfully"
-                                else:
-                                    msg = (
-                                        f"Tag '{tag}': Processed "
-                                        "(PR may have been created)"
-                                    )
-                            elif "success" in full_response.lower() and tag_mentioned:
-                                msg = f"Tag '{tag}': Successfully processed"
-                            elif "error" in full_response.lower() and tag_mentioned:
-                                msg = f"Tag '{tag}': Error during processing"
-                            else:
-                                msg = f"Tag '{tag}': Processed by agent"
-
-                            print(f"✅ Result for tag '{tag}': {msg}")
-                            result_messages.append(msg)
-
-                    except Exception as agent_error:
-                        print(f"⚠️ Agent streaming failed: {str(agent_error)}")
-                        print("🔄 Falling back to direct MCP tool calls...")
-
-                        # Import the MCP server functions directly as fallback
-                        try:
-                            import sys
-                            import importlib.util
-
-                            # Load the MCP server module
-                            spec = importlib.util.spec_from_file_location(
-                                "mcp_server", "./mcp_server.py"
-                            )
-                            mcp_module = importlib.util.module_from_spec(spec) # type: ignore
-                            spec.loader.exec_module(mcp_module) # type: ignore
-
-                            # Use the MCP tools directly for each tag
-                            for tag in all_tags:
-                                try:
-                                    print(
-                                        f"🔧 Directly calling get_current_tags for '{tag}'"
-                                    )
-                                    current_tags_result = mcp_module.get_current_tags(
-                                        repo_name
-                                    )
-                                    print(
-                                        f"📄 Current tags result: {current_tags_result}"
-                                    )
-
-                                    # Parse the JSON result
-                                    import json
-
-                                    tags_data = json.loads(current_tags_result)
-
-                                    if tags_data.get("status") == "success":
-                                        current_tags = tags_data.get("current_tags", [])
-                                        if tag in current_tags:
-                                            msg = f"Tag '{tag}': Already exists"
-                                            print(f"✅ {msg}")
-                                        else:
-                                            print(
-                                                f"🔧 Directly calling add_new_tag for '{tag}'"
-                                            )
-                                            add_result = mcp_module.add_new_tag(
-                                                repo_name, tag
-                                            )
-                                            print(f"📄 Add tag result: {add_result}")
-
-                                            add_data = json.loads(add_result)
-                                            if add_data.get("status") == "success":
-                                                pr_url = add_data.get("pr_url", "")
-                                                msg = f"Tag '{tag}': PR created - {pr_url}"
-                                            elif (
-                                                add_data.get("status")
-                                                == "already_exists"
-                                            ):
-                                                msg = f"Tag '{tag}': Already exists"
-                                            else:
-                                                msg = f"Tag '{tag}': {add_data.get('message', 'Processed')}"
-                                            print(f"✅ {msg}")
-                                    else:
-                                        error_msg = tags_data.get(
-                                            "error", "Unknown error"
-                                        )
-                                        msg = f"Tag '{tag}': Error - {error_msg}"
-                                        print(f"❌ {msg}")
-
-                                    result_messages.append(msg)
-
-                                except Exception as direct_error:
-                                    error_msg = f"Tag '{tag}': Direct call error - {str(direct_error)}"
-                                    print(f"❌ {error_msg}")
-                                    result_messages.append(error_msg)
-
-                        except Exception as fallback_error:
-                            error_msg = (
-                                f"Fallback approach failed: {str(fallback_error)}"
-                            )
-                            print(f"❌ {error_msg}")
-                            result_messages.append(error_msg)
-
-                except Exception as e:
-                    error_msg = f"Error during agent processing: {str(e)}"
-                    print(f"❌ {error_msg}")
-                    result_messages.append(error_msg)
-
-        # Store the interaction
-        base_url = "https://huggingface.co"
-        discussion_url = f"{base_url}/{repo_name}/discussions/{discussion_num}"
-
-        interaction = {
-            "timestamp": datetime.now().isoformat(),
-            "repo": repo_name,
-            "discussion_title": discussion_title,
-            "discussion_num": discussion_num,
-            "discussion_url": discussion_url,
-            "original_comment": comment_content,
-            "comment_author": comment_author,
-            "detected_tags": all_tags,
-            "results": result_messages,
-        }
-
-        tag_operations_store.append(interaction)
-        final_result = " | ".join(result_messages)
-        print(f"💾 Stored interaction and returning result: {final_result}")
-        return final_result
+    # Extract potential tags from comment and title
+    comment_tags = extract_tags_from_text(comment_content)
+    title_tags = extract_tags_from_text(discussion_title)
+    all_tags = list(set(comment_tags + title_tags))
+    
+    print(f"🔍 Found tags: {all_tags}")
+    
+    # Store operation for monitoring
+    operation = {
+        "timestamp": datetime.now().isoformat(),
+        "repo_name": repo_name,
+        "discussion_num": discussion_num,
+        "comment_author": comment_author,
+        "extracted_tags": all_tags,
+        "comment_preview": comment_content[:100] + "..." if len(comment_content) > 100 else comment_content,
+        "status": "processing"
+    }
+    tag_operations_store.append(operation)
+
+    if not all_tags:
+        operation["status"] = "no_tags"
+        operation["message"] = "No recognizable tags found"
+        print("❌ No tags found to process")
+        return
+
+    # Get MCP agent for tag processing
+    agent = await get_agent()
+    if not agent:
+        operation["status"] = "error"
+        operation["message"] = "Agent not configured (missing HF_TOKEN)"
+        print("❌ No agent available")
+        return
+
+    # Process each extracted tag
+    operation["results"] = []
+    for tag in all_tags:
+        try:
+            print(f"🤖 Processing tag '{tag}' for repo '{repo_name}'")
+            
+            # Create prompt for agent to handle tag processing
+            prompt = f"""
+            Analyze the repository '{repo_name}' and determine if the tag '{tag}' should be added.
+            
+            First, check the current tags using get_current_tags.
+            If '{tag}' is not already present and it's a valid tag, add it using add_new_tag.
+            
+            Repository: {repo_name}
+            Tag to process: {tag}
+            
+            Provide a clear summary of what was done.
+            """
+            
+            response = await agent.run(prompt) # type: ignore
+            print(f"🤖 Agent response for '{tag}': {response}")
+            
+            # Parse response and store result
+            tag_result = {
+                "tag": tag,
+                "response": response,
+                "timestamp": datetime.now().isoformat()
+            }
+            operation["results"].append(tag_result)
+            
+        except Exception as e:
+            error_msg = f"❌ Error processing tag '{tag}': {str(e)}"
+            print(error_msg)
+            operation["results"].append({
+                "tag": tag,
+                "error": str(e),
+                "timestamp": datetime.now().isoformat()
+            })
 
-    except Exception as e:
-        error_msg = f"❌ Fatal error in process_webhook_comment: {str(e)}"
-        print(error_msg)
-        return error_msg
+    operation["status"] = "completed"
+    print(f"✅ Completed processing {len(all_tags)} tags")
 
 
-@app.post("/webhook")
-async def webhook_handler(request: Request, background_tasks: BackgroundTasks):
-    """Handle HF Hub webhooks"""
-    webhook_secret = request.headers.get("X-Webhook-Secret")
-    if webhook_secret != WEBHOOK_SECRET:
-        print("❌ Invalid webhook secret")
-        return {"error": "Invalid webhook secret"}
+@app.get("/")
+async def root():
+    """Root endpoint with basic information"""
+    return {
+        "name": "HF Tagging Bot",
+        "status": "running",
+        "description": "Webhook listener for automatic model tagging",
+        "endpoints": {
+            "webhook": "/webhook",
+            "health": "/health",
+            "operations": "/operations"
+        }
+    }
 
-    payload = await request.json()
-    print(f"📥 Received webhook payload: {json.dumps(payload, indent=2)}")
 
-    event = payload.get("event", {})
-    scope = event.get("scope")
-    action = event.get("action")
+@app.get("/health")
+async def health_check():
+    """Health check endpoint for monitoring"""
+    agent = await get_agent()
+    
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "components": {
+            "webhook_secret": "configured" if WEBHOOK_SECRET else "missing",
+            "hf_token": "configured" if HF_TOKEN else "missing",
+            "mcp_agent": "ready" if agent else "not_ready"
+        }
+    }
 
-    print(f"🔍 Event details - scope: {scope}, action: {action}")
 
-    # Check if this is a discussion comment creation
-    scope_check = scope == "discussion"
-    action_check = action == "create"
-    not_pr = not payload["discussion"]["isPullRequest"]
-    scope_check = scope_check and not_pr
-    print(f"✅ not_pr: {not_pr}")
-    print(f"✅ scope_check: {scope_check}")
-    print(f"✅ action_check: {action_check}")
-
-    if scope_check and action_check:
-        # Verify we have the required fields
-        required_fields = ["comment", "discussion", "repo"]
-        missing_fields = [field for field in required_fields if field not in payload]
-
-        if missing_fields:
-            error_msg = f"Missing required fields: {missing_fields}"
-            print(f"❌ {error_msg}")
-            return {"error": error_msg}
-
-        print(f"🚀 Processing webhook for repo: {payload['repo']['name']}")
-        background_tasks.add_task(process_webhook_comment, payload)
-        return {"status": "processing"}
-
-    print(f"⏭️ Ignoring webhook - scope: {scope}, action: {action}")
-    return {"status": "ignored"}
-
-
-async def simulate_webhook(
-    repo_name: str, discussion_title: str, comment_content: str
-) -> str:
-    """Simulate webhook for testing"""
-    if not all([repo_name, discussion_title, comment_content]):
-        return "Please fill in all fields."
-
-    mock_payload = {
-        "event": {"action": "create", "scope": "discussion"},
-        "comment": {
-            "content": comment_content,
-            "author": {"id": "test-user-id"},
-            "id": "mock-comment-id",
-            "hidden": False,
-        },
-        "discussion": {
-            "title": discussion_title,
-            "num": len(tag_operations_store) + 1,
-            "id": "mock-discussion-id",
-            "status": "open",
-            "isPullRequest": False,
-        },
-        "repo": {
-            "name": repo_name,
-            "type": "model",
-            "private": False,
-        },
+@app.get("/operations")
+async def get_operations():
+    """Get recent tag operations for monitoring"""
+    # Return last 50 operations
+    recent_ops = tag_operations_store[-50:] if tag_operations_store else []
+    return {
+        "total_operations": len(tag_operations_store),
+        "recent_operations": recent_ops
     }
 
-    response = await process_webhook_comment(mock_payload)
-    return f"✅ Processed! Results: {response}"
+
+# async def simulate_webhook(
+#     repo_name: str, discussion_title: str, comment_content: str
+# ) -> str:
+#     """Simulate webhook for testing"""
+#     if not all([repo_name, discussion_title, comment_content]):
+#         return "Please fill in all fields."
+#
+#     mock_payload = {
+#         "event": {"action": "create", "scope": "discussion"},
+#         "comment": {
+#             "content": comment_content,
+#             "author": {"id": "test-user-id"},
+#             "id": "mock-comment-id",
+#             "hidden": False,
+#         },
+#         "discussion": {
+#             "title": discussion_title,
+#             "num": len(tag_operations_store) + 1,
+#             "id": "mock-discussion-id",
+#             "status": "open",
+#             "isPullRequest": False,
+#         },
+#         "repo": {
+#             "name": repo_name,
+#             "type": "model",
+#             "private": False,
+#         },
+#     }
+#
+#     response = await process_webhook_comment(mock_payload)
+#     return f"✅ Processed! Results: {response}"
 
 
 def create_gradio_app():
@@ -501,11 +654,11 @@ def create_gradio_app():
         with gr.Column():
             sim_result = gr.Textbox(label="Result", lines=8)
 
-        sim_btn.click(
-            fn=simulate_webhook,
-            inputs=[sim_repo, sim_title, sim_comment],
-            outputs=sim_result,
-        )
+        # sim_btn.click(
+        #     fn=simulate_webhook,
+        #     inputs=[sim_repo, sim_title, sim_comment],
+        #     outputs=sim_result,
+        # )
 
         gr.Markdown(f"""
         ## Recognized Tags: