added anime agent Config files

requirements.txt

@@ -1,3 +1,10 @@
 altair
 pandas
-streamlit
+streamlit
+smolagents
+smolagents[toolkit]
+streamlit
+DuckDuckGoSearchTool
+requests
+smolagents[openai]
+duckduckgo-search

src/agent.py

@@ -0,0 +1,47 @@
+from tools import add_anime, remove_anime, get_anime_list, search_anime, format_anime_list, display_anime_cards, hianime_watchlink, anime_suggestion
+from smolagents import CodeAgent, OpenAIServerModel
+from smolagents import DuckDuckGoSearchTool
+
+
+GEMINI_API_KEY = "AIzaSyDrSVoJnOEZclbciDf5hyor665iHG1nQsQ"
+DEEPSEEK_API_KEY = "sk-5901a93f69824788a61a2bc68925a3a9"
+
+def initialize_agent():
+    """
+    Initialize the agent with necessary tools and configurations.
+    """
+    tools = [
+        add_anime,
+        remove_anime,
+        get_anime_list,
+        search_anime,
+        format_anime_list,
+        display_anime_cards,
+        hianime_watchlink,
+        anime_suggestion,
+        DuckDuckGoSearchTool()
+    ]
+    
+    # Configure models
+    gemini_llm = OpenAIServerModel(
+        model_id="gemini-2.0-flash",
+        api_base="https://generativelanguage.googleapis.com/v1beta/openai/",
+        api_key=GEMINI_API_KEY,
+        max_tokens=1096,
+        temperature=0.5,
+    )
+    
+    deepseek_llm = OpenAIServerModel(
+        model_id="deepseek-chat",
+        api_base="https://api.deepseek.com",
+        api_key=DEEPSEEK_API_KEY,
+    )
+
+    
+    
+    return CodeAgent(
+        model=gemini_llm,  # Changed parameter to 'llm'
+        tools=tools,
+        # max_tokens=4096,
+        # temperature=0.5
+    )

src/auth.py

@@ -0,0 +1,108 @@
+# auth.py
+import streamlit as st
+import requests
+import webbrowser
+import secrets
+import threading
+import time
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from urllib.parse import urlparse, parse_qs
+
+# Configuration (move these to secrets.toml in production)
+CLIENT_ID = "e85f0329ae62138e962530f300c6549b"
+CLIENT_SECRET = "6a2bb65ea4fb863507cf7cf0452aa5c59825f142eee3c6bd639846155dddcec0"
+REDIRECT_URI = "http://localhost:8080/callback"
+PORT = 8080
+
+class MALAuth:
+    def __init__(self):
+        self.code_verifier = secrets.token_urlsafe(64)
+        self.code_challenge = self.code_verifier  # Using 'plain' method
+        self.auth_code = None
+        self.error = None
+
+    class OAuthHandler(BaseHTTPRequestHandler):
+        auth_code = None
+        error = None
+
+        def do_GET(self):
+            parsed = urlparse(self.path)
+            params = parse_qs(parsed.query)
+            if "code" in params:
+                MALAuth.OAuthHandler.auth_code = params["code"][0]
+                self.send_response(200)
+                self.end_headers()
+                self.wfile.write(b"Authorization successful! Return to the app.")
+            elif "error" in params:
+                MALAuth.OAuthHandler.error = params["error"][0]
+                self.send_response(400)
+                self.end_headers()
+                self.wfile.write(b"Authorization failed. Check your settings.")
+            else:
+                self.send_response(400)
+                self.end_headers()
+                self.wfile.write(b"Invalid request")
+
+    def run_server(self):
+        server = HTTPServer(('localhost', PORT), self.OAuthHandler)
+        server.timeout = 120
+        server.handle_request()
+
+    def start_oauth_flow(self):
+        server_thread = threading.Thread(target=self.run_server)
+        server_thread.daemon = True
+        server_thread.start()
+
+        auth_url = (
+            "https://myanimelist.net/v1/oauth2/authorize?"
+            f"response_type=code&"
+            f"client_id={CLIENT_ID}&"
+            f"code_challenge={self.code_challenge}&"
+            f"redirect_uri={REDIRECT_URI}"
+        )
+        webbrowser.open(auth_url)
+
+        start_time = time.time()
+        while not self.OAuthHandler.auth_code and not self.OAuthHandler.error:
+            if time.time() - start_time > 120:
+                return None, "Authorization timed out"
+            time.sleep(0.5)
+
+        return self.OAuthHandler.auth_code, self.OAuthHandler.error
+
+    def get_access_token(self, auth_code):
+        token_url = "https://myanimelist.net/v1/oauth2/token"
+        data = {
+            "client_id": CLIENT_ID,
+            "client_secret": CLIENT_SECRET,
+            "code": auth_code,
+            "code_verifier": self.code_verifier,
+            "grant_type": "authorization_code",
+            "redirect_uri": REDIRECT_URI
+        }
+        try:
+            response = requests.post(token_url, data=data)
+            response.raise_for_status()
+            return response.json()["access_token"], None
+        except requests.exceptions.HTTPError as e:
+            return None, f"Token exchange failed: {e.response.status_code} {e.response.text}"
+
+def login_button():
+    """Streamlit component for handling MAL login"""
+    if st.button("Login with MyAnimeList"):
+        with st.spinner("Authenticating..."):
+            auth = MALAuth()
+            auth_code, error = auth.start_oauth_flow()
+            
+            if error:
+                st.error(error)
+                return False
+                
+            access_token, error = auth.get_access_token(auth_code)
+            if error:
+                st.error(error)
+                return False
+                
+            st.session_state.access_token = access_token
+            st.rerun()
+    return True

src/streamlit_app.py

@@ -1,40 +1,112 @@
-import altair as alt
-import numpy as np
-import pandas as pd
+# app.py
 import streamlit as st
+from auth import login_button
+from agent import initialize_agent
 
-"""
-# Welcome to Streamlit!
+st.set_page_config(page_title="MyAnimeList Chat Assistant", page_icon="🎮")
+
+system_prompt = """
+You are a Helpful and Friendly Anime Assistant with comprehensive capabilities for managing and discovering anime content.
+
+## Core Responsibilities:
+- **MyAnimeList Management**: View, add, and remove anime from user's personal list
+- **Anime Recommendations**: Provide personalized suggestions based on user preferences
+- **Web Search**: Search for additional anime information when needed
+- **Watch Links**: Provide streaming links exclusively from HiAnime
 
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+## Tool Usage Guidelines:
+- **format_anime_list**: ALWAYS use this tool to display anime lists in a user-friendly format
+- **anime_suggestion**: Use for generating personalized anime recommendations
+- **display_anime_cards**: Format anime suggestions into visually appealing cards
+- **hianime_watchlink**: ONLY use this tool for providing watch links - no other sources
+- **DuckDuckGoSearchTool**: Use for additional web searches when more information is needed
 
-In the meantime, below is an example of what you can do with just a few lines of code:
+## Key Rules:
+1. Always format anime lists using the format_anime_list tool
+2. Present recommendations as cards using display_anime_cards
+3. Only provide HiAnime links for watching anime online
+4. Be helpful, friendly, and engaging in all interactions
+5. Search the web when you need additional context or information
 """
 
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+# Initialize session state variables
+if "access_token" not in st.session_state:
+    st.session_state.access_token = None
+if "messages" not in st.session_state:
+    st.session_state.messages = [
+        {"role": "assistant", "content": "Hi! I'm your MyAnimeList assistant. How can I help you today?"}
+    ]
+if "agent" not in st.session_state:
+    st.session_state.agent = None
+if "user_stats" not in st.session_state:
+    st.session_state.user_stats = None
+
+# --- Authentication Flow ---
+if not st.session_state.access_token:
+    st.title("MyAnimeList Assistant")
+    st.write("Please log in with your MyAnimeList account to continue.")
+    login_button()
+else:
+    # Initialize the agent after login if not already done
+    if st.session_state.agent is None:
+        with st.spinner("Setting up your personalized assistant..."):
+            # Option 1: Simple initialization with custom system prompt
+            st.session_state.agent = initialize_agent()
+            
+            # Option 2: Personalized initialization (if you have user stats)
+            # if st.session_state.user_stats:
+            #     st.session_state.agent = initialize_personalized_agent(st.session_state.user_stats)
+            # else:
+            #     st.session_state.agent = initialize_agent()
+
+    st.title("MyAnimeList Chat Assistant")
+    
+    # Add a sidebar with agent info (optional)
+    with st.sidebar:
+        st.header("Assistant Info")
+        st.write("🤖 **Specialized MAL Assistant**")
+        st.write("I can help you with:")
+        st.write("- View your anime list")
+        st.write("- Filter by status")
+        st.write("- Get recommendations")
+        st.write("- Analyze your viewing habits")
+        
+        # Reset conversation button
+        if st.button("🔄 Reset Conversation"):
+            st.session_state.messages = [
+                {"role": "assistant", "content": "Hi! I'm your MyAnimeList assistant. How can I help you today?"}
+            ]
+            st.rerun()
+
+    # Display chat history
+    for msg in st.session_state.messages:
+        with st.chat_message(msg["role"]):
+            st.markdown(msg["content"])  # Use markdown for better table rendering
+
+    # Chat input
+    if prompt := st.chat_input("Ask me anything about your anime list..."):
+        # Add user message
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        
+        # Display user message immediately
+        with st.chat_message("user"):
+            st.markdown(prompt)
+
+        # Get agent response
+        with st.chat_message("assistant"):
+            with st.spinner("Analyzing your request..."):
+                main_prompt = f"""
+                System: {system_prompt}
+                
+                User: {prompt}
+                """
+                try:
+                    response = st.session_state.agent.run(prompt, reset=False)  # Keep context
+                    st.markdown(response)
+                    st.session_state.messages.append({"role": "assistant", "content": response})
+                except Exception as e:
+                    error_msg = f"Sorry, I encountered an error: {str(e)}"
+                    st.error(error_msg)
+                    st.session_state.messages.append({"role": "assistant", "content": error_msg})
+
+        st.rerun()  # Refresh to display the new message

src/tools.py

@@ -0,0 +1,254 @@
+from smolagents import tool
+import streamlit as st
+import requests
+import pandas as pd
+# from duckduckgo_search import DDGS
+
+# def duckduckgo_search(query: str, max_results: int = 3) -> list:
+#     """Search the web using DuckDuckGo"""
+#     with DDGS() as ddgs:
+#         return [r for r in ddgs.text(query, max_results=max_results)]
+
+#MAL Tools
+@tool
+def add_anime(anime_id: int, status:str = "Watching", episodes_watched: int = 0, score: int = 0) -> str:
+    """
+    Add an anime to your MyAnimeList.
+    Args:
+        anime_id (int): The ID of the anime to add.
+        status (str): The status of the anime (e.g., "Watching", "Completed", "On-Hold", "Dropped", "Plan to Watch").
+        episodes_watched (int): The number of episodes watched.
+        score (int): Your score for the anime (0-10).
+    Returns:
+        str: A message indicating the success or failure of the operation.
+    """
+    try:
+        response = requests.patch(  # Changed to PATCH
+            f"https://api.myanimelist.net/v2/anime/{anime_id}/my_list_status",
+            headers={
+                "Authorization": f"Bearer {st.session_state.access_token}",
+                "Content-Type": "application/x-www-form-urlencoded"  # Required
+            },
+            data={  # Use data instead of json
+                "status": status,
+                "num_watched_episodes": episodes_watched,
+                "score": score
+            }
+        )
+        response.raise_for_status()
+        return "Anime added/updated successfully!"
+    except Exception as e:
+        return f"Failed to add anime: {str(e)}"
+
+@tool
+def remove_anime(anime_id: int) -> str:
+    """
+    Remove an anime from your MyAnimeList.
+    Args:
+        anime_id (int): The ID of the anime to remove.
+    Returns:
+        str: A message indicating the success or failure of the operation.
+    """
+    try:
+        response = requests.delete(
+            f"https://api.myanimelist.net/v2/anime/{anime_id}/my_list_status",
+            headers={
+                "Authorization": f"Bearer {st.session_state.access_token}",
+            }
+        )
+        response.raise_for_status()
+        return "Anime removed successfully!"
+    except Exception as e:
+        return f"Failed to remove anime: {e}"
+    
+@tool
+def get_anime_list(status_filter: str = None) -> str:
+    """
+    Get the list of anime in your MyAnimeList.
+    Args:
+        status_filter (str): Filter by status (e.g., "Watching", "Completed", "On-Hold", "Dropped", "Plan to Watch").
+    Returns:
+        str: A markdown table representation of the anime list with columns: Name, Status, Episodes Watched, Total Episodes, and Score.
+    """
+    try:
+        params = {
+            "fields": "list_status,media_type,num_episodes",
+            "limit": 100
+        }
+        if status_filter:
+            params["status"] = status_filter.lower().replace(" ", "_")  # Convert to MAL format
+
+        response = requests.get(
+            "https://api.myanimelist.net/v2/users/@me/animelist",
+            headers={"Authorization": f"Bearer {st.session_state.access_token}"},
+            params=params
+        )
+        response.raise_for_status()  # Check for HTTP errors
+        return format_anime_list(response.json().get("data", []))
+    except Exception as e:
+        return f"Error fetching list: {str(e)}"
+
+    
+@tool
+def search_anime(query: str) -> str:
+    """
+    Search for anime by title.
+    Args:
+        query (str): The title of the anime to search for.
+    Returns:
+        str: A string representation of the search results.
+    """
+    try:
+        response = requests.get(
+            "https://api.myanimelist.net/v2/anime",
+            headers={
+                "Authorization": f"Bearer {st.session_state.access_token}",
+            },
+            params={
+                "q": query,
+                "limit": 10
+            }
+        )
+        response.raise_for_status()
+        return response.json()
+    except Exception as e:
+        return f"Failed to search anime: {e}"
+    
+@tool    
+def format_anime_list(anime_list: list) -> str:
+    """
+    Format the anime list as a markdown table.
+    Args:
+        anime_list (list): The list of anime entries.
+    Returns:
+        str: A markdown table representation of the anime list with columns: Name, Status, Episodes Watched, Total Episodes, and Score.
+    """
+    if not anime_list:
+        return "No anime found."
+    
+    # Create markdown table header
+    table = "| Name | Status | Episodes Watched | Total Episodes | Score |\n"
+    table += "|------|--------|------------------|----------------|-------|\n"
+    
+    # Add rows for each anime
+    for entry in anime_list:
+        anime = entry["node"]
+        list_status = entry["list_status"]
+        
+        title = anime["title"]
+        status = list_status["status"].replace("_", " ").title()
+        episodes_watched = list_status["num_episodes_watched"]
+        total_episodes = anime.get("num_episodes", "Unknown")
+        score = list_status.get("score", "Not Rated")
+        
+        # Handle score display
+        score_display = str(score) if score and score > 0 else "Not Rated"
+        
+        # Escape pipe characters in title if any
+        title_escaped = title.replace("|", "\\|")
+        
+        table += f"| {title_escaped} | {status} | {episodes_watched} | {total_episodes} | {score_display} |\n"
+    
+    return table
+@tool
+def display_anime_cards(search_results: list[dict]) -> str:
+     """
+    Render a list of anime search results as visually formatted cards using Streamlit.
+
+    This function displays multiple anime entries in a structured, scrollable layout,
+    where each anime is presented as a card with its cover image, title (linked to detail page),
+    rating, episode count, and a truncated synopsis. Designed for use in interactive applications
+    like SmolAgents, this enhances user experience by presenting search data in an intuitive format.
+
+    Args:
+        search_results (list[dict]): A list of dictionaries, where each dictionary contains metadata
+            for a single anime. Expected keys in each dictionary:
+                - title (str): Title of the anime.
+                - cover_image (str): URL of the anime’s cover/poster image.
+                - rating (float): Average rating (0.0 to 10.0 scale).
+                - episodes (int): Total number of episodes.
+                - synopsis (str): Brief plot summary.
+                - url (str): Link to the anime’s full detail page.
+
+    Returns:
+        None: The function does not return any value.
+        It directly renders UI components using the Streamlit.
+
+    Example:
+         search_results = [
+             {
+                 "title": "Naruto",
+                 "cover_image": "https://cdn.example.com/naruto.jpg",
+                 "rating": 7.9,
+                 "episodes": 220,
+                 "synopsis": "A young ninja strives to become Hokage...",
+                 "url": "https://myanimelist.net/anime/20/Naruto"
+             },
+             ...
+         ]
+        display_anime_cards(search_results)
+    """
+     pass
+    # for anime in search_results:
+    #     # Extract cover image URL (prefer large, then medium, then fallback)
+    #     cover_url = None
+    #     if "main_picture" in anime:
+    #         cover_url = anime["main_picture"].get("large") or anime["main_picture"].get("medium")
+    #     elif "cover_url" in anime:
+    #         cover_url = anime["cover_url"]
+    #     else:
+    #         cover_url = "https://via.placeholder.com/150x220.png?text=No+Image"
+
+    #     with st.container(border=True):
+    #         col1, col2 = st.columns([1, 3])
+    #         with col1:
+    #             st.image(cover_url, width=150)
+    #         with col2:
+    #             st.markdown(f"### {anime.get('title', 'Untitled')}")
+    #             mal_score = anime.get('score', 0)
+    #             normalized_rating = mal_score / 2  # Convert to 0-5 scale
+    #             full_stars = int(normalized_rating)
+    #             half_star = 1 if normalized_rating - full_stars >= 0.5 else 0
+    #             empty_stars = 5 - full_stars - half_star
+    #             stars = "⭐" * full_stars + "⯨" * half_star + "✰" * empty_stars
+    #             st.markdown(f"**MAL Score:** {stars} ({mal_score}/10)")
+    #             if 'episodes' in anime:
+    #                 st.caption(f"Episodes: {anime['episodes']}")
+    #             if 'status' in anime:
+    #                 st.caption(f"Airing Status: {anime['status'].capitalize()}")
+    # return "Displayed anime results successfully"
+
+@tool
+def hianime_watchlink(query: str) -> str:
+    """
+    Search for a HiAnime watch link for the anime in query make Sure its hianime.sx link.
+    Args:
+        query (str): The title of the anime to search for.
+    Returns:
+        str: A string representation of the hianime watch link or an error message.
+    """
+    pass
+    # try:
+    #     results = duckduckgo_search(f"{query} site:hianime.tv", max_results=1)
+    #     return results[0]['href'] if results else "No HiAnime link found"
+    # except Exception as e:
+    #     return f"Search failed: {str(e)}"
+    
+
+@tool
+def anime_suggestion(query: str) -> str:
+    """
+    Suggest an anime based on a query.
+    Args:
+        query (str): The title or description of the anime to suggest.
+    Returns:
+        str: A tabular representation of the suggested anime or an error message, this suggestion than searched through search_anime tool to get more information.
+    """
+    # try:
+    #     results = duckduckgo_search(query + " anime suggestion")
+    #     if not results:
+    #         return "No anime suggestion found."
+    #     return results[0].get("href", "No valid suggestion found.")
+    # except Exception as e:
+    #     return f"Failed to suggest anime: {e}"
+    pass