Update app.py

app.py

@@ -7,6 +7,16 @@ from tools.final_answer import FinalAnswerTool
 
 from Gradio_UI import GradioUI
 
+#Utility function to help refine the search and use of our api calls
+def normalize_input(text: str) -> str:
+    return text.strip().lower().replace("'", "").replace(",", "")
+
+def best_match(name: str, options: list) -> str:
+    matches = get_close_matches(normalize_input(name), 
+                               [normalize_input(o) for o in options], 
+                               n=1, cutoff=0.8)
+    return options[matches[0]] if matches else None
+
 # Below is an example of a tool that does nothing. Amaze us with your creativity !
 @tool
 def my_custom_tool(arg1:str, arg2:int)-> str: #it's import to specify the return type
@@ -20,70 +30,100 @@ def my_custom_tool(arg1:str, arg2:int)-> str: #it's import to specify the return
 
 
 @tool
-def get_asoiaf_book(book_id: int) -> str:
-    """Retrieves information about a book from 'A Song of Ice and Fire' series by ID.
-    Args:
-        book_id: The numeric ID of the book (1-12)
-    """
+def asoiaf_book(query: str) -> str:
+    """Handle book queries by ID or name. Returns JSON with {title, authors, pages, characters}"""
     try:
-        response = requests.get(f"https://anapioficeandfire.com/api/books/{book_id}")
+        if query.isdigit():
+            book_id = int(query)
+            response = requests.get(f"https://anapioficeandfire.com/api/books/{book_id}")
+        else:
+            response = requests.get("https://anapioficeandfire.com/api/books")
+            
         if response.status_code == 200:
-            book = response.json()
-            return (
-                f"Book {book_id}: {book['name']}\n"
-                f"Authors: {', '.join(book['authors'])}\n"
-                f"Pages: {book['numberOfPages']}\n"
-                f"Characters: {len(book['characters'])}"
-            )
-        return f"Error: Book with ID {book_id} not found"
+            books = response.json() if isinstance(response.json(), list) else [response.json()]
+            matched = next((b for b in books if normalize_input(b["name"]) == normalize_input(query)), None)
+            
+            if matched:
+                return json.dumps({
+                    "title": matched["name"],
+                    "authors": matched["authors"],
+                    "pages": matched["numberOfPages"],
+                    "characters": len(matched["characters"])
+                })
+                
+            return json.dumps({"error": f"No book matching '{query}' found"})
+            
+        return json.dumps({"error": "Book API unavailable"})
+    
     except Exception as e:
-        return f"API Error: {str(e)}"
+        return json.dumps({"error": f"Book search failed: {str(e)}"})
 
 @tool
-def get_asoiaf_character(name: str) -> str:
-    """Searches for a character by name in the Game of Thrones universe.
-    Args:
-        name: The full name of the character (e.g., 'Jon Snow')
-    """
+def asoiaf_character(query: str) -> str:
+    """Resolve questions about characters. Returns JSON with: {name, aliases, titles, actor, house, error}"""
     try:
+        clean_query = normalize_input(query)
+        name_keywords = ["who is", "plays", "actor for", "information about"]
+        name = next((clean_query.split(kw)[-1].strip() for kw in name_keywords 
+                    if kw in clean_query), clean_query)
+        
         response = requests.get(
             "https://anapioficeandfire.com/api/characters",
-            params={"name": name}
+            params={"name": name},
+            timeout=5
         )
+        
         if response.status_code == 200:
-            characters = response.json()
-            if characters:
-                char = characters[0]
-                return (
-                    f"Character: {char['name']}\n"
-                    f"Aliases: {', '.join(char['aliases'])}\n"
-                    f"Titles: {', '.join(char['titles'])}\n"
-                    f"Played by: {char['playedBy'][0] if char['playedBy'] else 'Unknown'}"
-                )
-            return f"No character named '{name}' found"
-        return f"API Error: HTTP {response.status_code}"
+            chars = response.json()
+            if not chars:
+                all_chars = requests.get("https://anapioficeandfire.com/api/characters").json()
+                aliases = [alias for c in all_chars for alias in c["aliases"]]
+                matched = best_match(name, aliases) or best_match(name, [c["name"] for c in all_chars])
+                if matched:
+                    return asoiaf_character(matched)
+                return json.dumps({"error": f"No match for '{query}'. Try full names like 'Daenerys Targaryen'"})
+
+            char = chars[0]
+            result = {
+                "name": char.get("name"),
+                "aliases": char.get("aliases", []),
+                "titles": char.get("titles", []),
+                "actor": char.get("playedBy", ["Unknown"])[0],
+                "house": char.get("allegiances", ["Unknown"])[0].split("/")[-1],
+                "source": "book"
+            }
+            return json.dumps(result, ensure_ascii=False)
+            
+        return json.dumps({"error": "API unavailable"})
+    
     except Exception as e:
-        return f"Search Error: {str(e)}"
+        return json.dumps({"error": f"Search failed: {str(e)}"})
 
 @tool
-def get_asoiaf_house(region: str) -> str:
-    """Finds houses from a specific region in Westeros.
-    Args:
-        region: The region to search (e.g., 'The North', 'The Vale')
-    """
+def asoiaf_house(query: str) -> str:
+    """Resolve house-related queries. Returns JSON with {name, region, words, members}"""
     try:
         response = requests.get(
             "https://anapioficeandfire.com/api/houses",
-            params={"region": region}
+            params={"region": query},
+            timeout=5
         )
+        
         if response.status_code == 200:
             houses = response.json()
             if houses:
-                return f"Found {len(houses)} houses in {region}\nFirst result: {houses[0]['name']}"
-            return f"No houses found in {region}"
-        return f"API Error: HTTP {response.status_code}"
+                return json.dumps({
+                    "name": houses[0]["name"],
+                    "region": houses[0]["region"],
+                    "words": houses[0]["words"],
+                    "members": len(houses[0]["swornMembers"])
+                })
+            return json.dumps({"error": f"No houses found matching '{query}'"})
+            
+        return json.dumps({"error": "House API unavailable"})
+    
     except Exception as e:
-        return f"Region Search Error: {str(e)}"
+        return json.dumps({"error": f"House search failed: {str(e)}"})
 
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
@@ -122,6 +162,16 @@ image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_co
 
 with open("prompts.yaml", 'r') as stream:
     prompt_templates = yaml.safe_load(stream)
+
+
+# Add JSON parsing instructions to the agent prompt
+prompt_templates['system'] += """
+When using API tools:
+1. Always parse JSON responses first
+2. Check for "error" keys before proceeding
+3. Use get() for optional fields
+4. Handle empty values gracefully
+"""
     
 agent = CodeAgent(
     model=model,