fix integration and improve logging

app.py

@@ -82,25 +82,43 @@ app.add_middleware(CORSMiddleware, allow_origins=["*"])
 
 async def get_agent():
     """Get or create Agent instance"""
+    print("🤖 get_agent() called...")
     global agent_instance
     if agent_instance is None and HF_TOKEN:
-        agent_instance = Agent(
-            model=HF_MODEL,
-            provider=DEFAULT_PROVIDER,
-            api_key=HF_TOKEN,
-            servers=[
-                {
-                    "type": "stdio",
-                    "config": {
-                        "command": "python",
-                        "args": ["mcp_server.py"],
-                        "cwd": ".",  # Ensure correct working directory
-                        "env": {"HF_TOKEN": HF_TOKEN} if HF_TOKEN else {},
-                    },
-                }
-            ],
-        )
-        await agent_instance.load_tools()
+        print("🔧 Creating new Agent instance...")
+        print(f"🔑 HF_TOKEN present: {bool(HF_TOKEN)}")
+        print(f"🤖 Model: {HF_MODEL}")
+        print(f"🔗 Provider: {DEFAULT_PROVIDER}")
+
+        try:
+            agent_instance = Agent(
+                model=HF_MODEL,
+                provider=DEFAULT_PROVIDER,
+                api_key=HF_TOKEN,
+                servers=[
+                    {
+                        "type": "stdio",
+                        "config": {
+                            "command": "python",
+                            "args": ["mcp_server.py"],
+                            "cwd": ".",  # Ensure correct working directory
+                            "env": {"HF_TOKEN": HF_TOKEN} if HF_TOKEN else {},
+                        },
+                    }
+                ],
+            )
+            print("✅ Agent instance created successfully")
+            print("🔧 Loading tools...")
+            await agent_instance.load_tools()
+            print("✅ Tools loaded successfully")
+        except Exception as e:
+            print(f"❌ Error creating/loading agent: {str(e)}")
+            agent_instance = None
+    elif agent_instance is None:
+        print("❌ No HF_TOKEN available, cannot create agent")
+    else:
+        print("✅ Using existing agent instance")
+
     return agent_instance
 
 
@@ -144,105 +162,225 @@ def extract_tags_from_text(text: str) -> List[str]:
 
 async def process_webhook_comment(webhook_data: Dict[str, Any]):
     """Process webhook to detect and add tags"""
-    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")
-
-    # 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))
-
-    result_messages = []
-
-    if not all_tags:
-        result_messages.append("No recognizable tags found in the discussion.")
-    else:
-        agent = await get_agent()
-        if not agent:
-            msg = "Error: Agent not configured (missing HF_TOKEN)"
+    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:
-            # Process each tag
-            for tag in all_tags:
+            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:
-                    # Get response from agent
-                    responses = []
-                    prompt = (
-                        f"Add the tag '{tag}' to repository {repo_name} "
-                        "using add_new_tag"
-                    )
+                    # 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)}
 
-                    async for item in agent.run(prompt):
-                        # Just collect the response content
-                        responses.append(str(item))
+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
 
-                    response_text = " ".join(responses) if responses else "Completed"
+Please process all {len(all_tags)} tags: {", ".join(all_tags)}
+"""
 
-                    # Try to parse JSON from response if possible
-                    try:
-                        # Look for JSON in the response
-                        json_found = False
-                        for response_part in responses:
-                            response_str = str(response_part)
-                            if "{" in response_str and "}" in response_str:
-                                # Try to extract JSON from the response
-                                start_idx = response_str.find("{")
-                                end_idx = response_str.rfind("}") + 1
-                                json_str = response_str[start_idx:end_idx]
+                    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)
+                            spec.loader.exec_module(mcp_module)
+
+                            # Use the MCP tools directly for each tag
+                            for tag in all_tags:
                                 try:
-                                    json_response = json.loads(json_str)
-                                    status = json_response.get("status")
-                                    if status == "success":
-                                        pr_url = json_response.get("pr_url", "")
-                                        msg = f"Tag '{tag}': PR created - {pr_url}"
-                                    elif status == "already_exists":
-                                        msg = f"Tag '{tag}': Already exists"
+                                    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:
-                                        tag_msg = json_response.get(
-                                            "message", "Processed"
+                                        error_msg = tags_data.get(
+                                            "error", "Unknown error"
                                         )
-                                        msg = f"Tag '{tag}': {tag_msg}"
-                                    json_found = True
-                                    break
-                                except json.JSONDecodeError:
-                                    continue
+                                        msg = f"Tag '{tag}': Error - {error_msg}"
+                                        print(f"❌ {msg}")
 
-                        if not json_found:
-                            # If no JSON found, use the response as is
-                            msg = f"Tag '{tag}': {response_text}"
+                                    result_messages.append(msg)
 
-                    except Exception:
-                        msg = f"Tag '{tag}': Response parse error - {response_text}"
+                                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)
 
-                    result_messages.append(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 processing tag '{tag}': {str(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)
-    return " | ".join(result_messages)
+        # 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")

mcp_server.py

@@ -25,12 +25,19 @@ mcp = FastMCP("hf-tagging-bot")
 @mcp.tool()
 def get_current_tags(repo_id: str) -> str:
     """Get current tags from a HuggingFace model repository"""
+    print(f"🔧 get_current_tags called with repo_id: {repo_id}")
+
     if not hf_api:
-        return json.dumps({"error": "HF token not configured"})
+        error_result = {"error": "HF token not configured"}
+        json_str = json.dumps(error_result)
+        print(f"❌ No HF API token - returning: {json_str}")
+        return json_str
 
     try:
+        print(f"📡 Fetching model info for: {repo_id}")
         info = model_info(repo_id=repo_id, token=HF_TOKEN)
         current_tags = info.tags if info.tags else []
+        print(f"🏷️ Found {len(current_tags)} tags: {current_tags}")
 
         result = {
             "status": "success",
@@ -38,45 +45,63 @@ def get_current_tags(repo_id: str) -> str:
             "current_tags": current_tags,
             "count": len(current_tags),
         }
-        return json.dumps(result)
+        json_str = json.dumps(result)
+        print(f"✅ get_current_tags returning: {json_str}")
+        return json_str
 
     except Exception as e:
+        print(f"❌ Error in get_current_tags: {str(e)}")
         error_result = {"status": "error", "repo_id": repo_id, "error": str(e)}
-        return json.dumps(error_result)
+        json_str = json.dumps(error_result)
+        print(f"❌ get_current_tags error returning: {json_str}")
+        return json_str
 
 
 @mcp.tool()
 def add_new_tag(repo_id: str, new_tag: str) -> str:
     """Add a new tag to a HuggingFace model repository via PR"""
+    print(f"🔧 add_new_tag called with repo_id: {repo_id}, new_tag: {new_tag}")
+
     if not hf_api:
-        return json.dumps({"error": "HF token not configured"})
+        error_result = {"error": "HF token not configured"}
+        json_str = json.dumps(error_result)
+        print(f"❌ No HF API token - returning: {json_str}")
+        return json_str
 
     try:
         # Get current model info and tags
+        print(f"📡 Fetching current model info for: {repo_id}")
         info = model_info(repo_id=repo_id, token=HF_TOKEN)
         current_tags = info.tags if info.tags else []
+        print(f"🏷️ Current tags: {current_tags}")
 
         # Check if tag already exists
         if new_tag in current_tags:
+            print(f"⚠️ Tag '{new_tag}' already exists in {current_tags}")
             result = {
                 "status": "already_exists",
                 "repo_id": repo_id,
                 "tag": new_tag,
                 "message": f"Tag '{new_tag}' already exists",
             }
-            return json.dumps(result)
+            json_str = json.dumps(result)
+            print(f"🏷️ add_new_tag (already exists) returning: {json_str}")
+            return json_str
 
         # Add the new tag to existing tags
         updated_tags = current_tags + [new_tag]
+        print(f"🆕 Will update tags from {current_tags} to {updated_tags}")
 
         # Create model card content with updated tags
         try:
             # Load existing model card
+            print(f"📄 Loading existing model card...")
             card = ModelCard.load(repo_id, token=HF_TOKEN)
             if not hasattr(card, "data") or card.data is None:
                 card.data = ModelCardData()
         except HfHubHTTPError:
             # Create new model card if none exists
+            print(f"📄 Creating new model card (none exists)")
             card = ModelCard("")
             card.data = ModelCardData()
 
@@ -100,6 +125,8 @@ This PR adds the `{new_tag}` tag to the model repository.
 **New tags:** {", ".join(updated_tags)}
 """
 
+        print(f"🚀 Creating PR with title: {pr_title}")
+
         # Create commit with updated model card using CommitOperationAdd
         from huggingface_hub import CommitOperationAdd
 
@@ -120,6 +147,8 @@ This PR adds the `{new_tag}` tag to the model repository.
         pr_url_attr = commit_info.pr_url
         pr_url = pr_url_attr if hasattr(commit_info, "pr_url") else str(commit_info)
 
+        print(f"✅ PR created successfully! URL: {pr_url}")
+
         result = {
             "status": "success",
             "repo_id": repo_id,
@@ -129,16 +158,26 @@ This PR adds the `{new_tag}` tag to the model repository.
             "new_tags": updated_tags,
             "message": f"Created PR to add tag '{new_tag}'",
         }
-        return json.dumps(result)
+        json_str = json.dumps(result)
+        print(f"✅ add_new_tag success returning: {json_str}")
+        return json_str
 
     except Exception as e:
+        print(f"❌ Error in add_new_tag: {str(e)}")
+        print(f"❌ Error type: {type(e)}")
+        import traceback
+
+        print(f"❌ Traceback: {traceback.format_exc()}")
+
         error_result = {
             "status": "error",
             "repo_id": repo_id,
             "tag": new_tag,
             "error": str(e),
         }
-        return json.dumps(error_result)
+        json_str = json.dumps(error_result)
+        print(f"❌ add_new_tag error returning: {json_str}")
+        return json_str
 
 
 if __name__ == "__main__":