tool error fix

agent.py

@@ -19,6 +19,9 @@ interpreter_instance = CodeInterpreter()
 
 from image_processing import *
 
+from langchain_core.tools import tool
+import speech_recognition as sr
+
 """Langraph"""
 from langgraph.graph import START, StateGraph, MessagesState
 from langchain_community.tools.tavily_search import TavilySearchResults
@@ -54,8 +57,13 @@ def tool_response(success: bool, data=None, error=None):
 from typing import Any
 
 @tool
-def multiply(a: Any, b: Any):
-    """Multiply two numbers and return the product."""
+def multiply(a: float, b: float) -> float:
+    """
+    Multiplies two numbers.
+    Args:
+        a (float): the first number
+        b (float): the second number
+    """
     logger.info("multiply called with a=%s, b=%s", a, b)
     try:
         a = float(a)
@@ -67,8 +75,13 @@ def multiply(a: Any, b: Any):
         return tool_response(False, error=f"Invalid input: {e}")
 
 @tool
-def add(a: Any, b: Any):
-    """Add two numbers and return the sum."""
+def add(a: float, b: float) -> float:
+    """
+    Adds two numbers.
+    Args:
+        a (float): the first number
+        b (float): the second number
+    """
     logger.info("add called with a=%s, b=%s", a, b)
     try:
         a = float(a)
@@ -79,8 +92,13 @@ def add(a: Any, b: Any):
         return tool_response(False, error=f"Invalid input: {e}")
 
 @tool
-def subtract(a: Any, b: Any):
-    """Subtract b from a and return the result."""
+def subtract(a: float, b: float) -> int:
+    """
+    Subtracts two numbers.
+    Args:
+        a (float): the first number
+        b (float): the second number
+    """
     logger.info("subtract called with a=%s, b=%s", a, b)
     try:
         a = float(a)
@@ -91,8 +109,13 @@ def subtract(a: Any, b: Any):
         return tool_response(False, error=f"Invalid input: {e}")
 
 @tool
-def divide(a: Any, b: Any):
-    """Divide a by b and return the quotient."""
+def divide(a: float, b: float) -> float:
+    """
+    Divides two numbers.
+    Args:
+        a (float): the first float number
+        b (float): the second float number
+    """
     logger.info("divide called with a=%s, b=%s", a, b)
     try:
         a = float(a)
@@ -105,20 +128,30 @@ def divide(a: Any, b: Any):
         return tool_response(False, error=f"Invalid input: {e}")
 
 @tool
-def modulus(a: Any, b: Any):
-    """Return the remainder of a divided by b."""
+def modulus(a: int, b: int) -> int:
+    """
+    Get the modulus of two numbers.
+    Args:
+        a (int): the first number
+        b (int): the second number
+    """
     logger.info("modulus called with a=%s, b=%s", a, b)
     try:
-        a = float(a)
-        b = float(b)
+        a = int(a)
+        b = int(b)
         return tool_response(True, a % b)
     except Exception as e:
         logger.error("modulus failed: %s", str(e))
         return tool_response(False, error=f"Invalid input: {e}")
 
 @tool
-def power(a: Any, b: Any):
-    """Raise a to the power of b."""
+def power(a: float, b: float) -> float:
+    """
+    Get the power of two numbers.
+    Args:
+        a (float): the first number
+        b (float): the second number
+    """
     logger.info("power called with a=%s, b=%s", a, b)
     try:
         a = float(a)
@@ -129,8 +162,12 @@ def power(a: Any, b: Any):
         return tool_response(False, error=f"Invalid input: {e}")
 
 @tool
-def square_root(a: Any):
-    """Return the square root of a number."""
+def square_root(a: float) -> float|complex:
+    """
+    Get the square root of a number.
+    Args:
+        a (float): the number to get the square root of
+    """
     logger.info("square_root called with a=%s", a)
     try:
         a = float(a)
@@ -141,6 +178,30 @@ def square_root(a: Any):
     except Exception as e:
         logger.error("square_root failed: %s", str(e))
         return tool_response(False, error=f"Invalid input: {e}")
+    
+
+### =============== Audio TOOLS =============== ###
+
+@tool("extract_text_from_audio", return_direct=True)
+def extract_text_from_audio(audio_file_path: str) -> str:
+    """
+    Extract text from an audio file using speech recognition.
+    Args:
+        audio_file_path (str): Path to the audio file (wav, mp3, etc.)
+    Returns:
+        str: Transcribed text from the audio.
+    """
+    recognizer = sr.Recognizer()
+    with sr.AudioFile(audio_file_path) as source:
+        audio = recognizer.record(source)
+    try:
+        # Use Whisper (local) recognizer as recommended by SpeechRecognition[whisper-local]
+        text = recognizer.recognize_whisper(audio)
+    except sr.UnknownValueError:
+        text = "Could not understand audio."
+    except sr.RequestError as e:
+        text = f"Recognition error: {e}"
+    return text
 
 # =========================
 # 📂 File Tools
@@ -148,7 +209,12 @@ def square_root(a: Any):
 
 @tool
 def save_and_read_file(filename: str, content: str):
-    """Save content to a file and return the content back."""
+    """
+    Save content to a file and return the path.
+    Args:
+        content (str): the content to save to the file
+        filename (str, optional): the name of the file. If not provided, a random name file will be created.
+    """
     logger.info("save_and_read_file called with filename=%s", filename)
     try:
         with open(filename, "w", encoding="utf-8") as f:
@@ -163,7 +229,12 @@ def save_and_read_file(filename: str, content: str):
 
 @tool
 def download_file_from_url(url: str):
-    """Download a file from a URL and return its local path."""
+    """
+    Download a file from a URL and save it to a temporary location.
+    Args:
+        url (str): the URL of the file to download.
+        filename (str, optional): the name of the file. If not provided, a random name file will be created.
+    """
     logger.info("download_file_from_url called with url=%s", url)
     try:
         if url.startswith("file://"):
@@ -184,101 +255,303 @@ def download_file_from_url(url: str):
 # =========================
 
 @tool
-def extract_text_from_image(image_path: str):
-    """Extract text from an image using OCR."""
-    logger.info("extract_text_from_image called with image_path=%s", image_path)
+def extract_text_from_image(image_path: str) -> str:
+    """
+    Extract text from an image using OCR library pytesseract (if available).
+    Args:
+        image_path (str): the path to the image file.
+    """
     try:
-        text = pytesseract.image_to_string(Image.open(image_path))
-        return tool_response(True, text.strip())
+        # Open the image
+        image = Image.open(image_path)
+
+        # Extract text from the image
+        text = pytesseract.image_to_string(image)
+
+        return f"Extracted text from image:\n\n{text}"
     except Exception as e:
-        logger.error("extract_text_from_image failed: %s", str(e))
-        return tool_response(False, error=f"OCR error: {e}")
+        return f"Error extracting text from image: {str(e)}"
 
 
 @tool
-def analyze_image(image_path: str):
-    """Return basic analysis (size, mode) of an image."""
-    logger.info("analyze_image called with image_path=%s", image_path)
+def analyze_image(image_base64: str) -> Dict[str, Any]:
+    """
+    Analyze basic properties of an image (size, mode, color analysis, thumbnail preview).
+    Args:
+        image_base64 (str): Base64 encoded image string
+    Returns:
+        Dictionary with analysis result
+    """
     try:
-        with Image.open(image_path) as img:
-            data = {"format": img.format, "mode": img.mode, "size": img.size}
-        return tool_response(True, data)
+        img = decode_image(image_base64)
+        width, height = img.size
+        mode = img.mode
+
+        if mode in ("RGB", "RGBA"):
+            arr = np.array(img)
+            avg_colors = arr.mean(axis=(0, 1))
+            dominant = ["Red", "Green", "Blue"][np.argmax(avg_colors[:3])]
+            brightness = avg_colors.mean()
+            color_analysis = {
+                "average_rgb": avg_colors.tolist(),
+                "brightness": brightness,
+                "dominant_color": dominant,
+            }
+        else:
+            color_analysis = {"note": f"No color analysis for mode {mode}"}
+
+        thumbnail = img.copy()
+        thumbnail.thumbnail((100, 100))
+        thumb_path = save_image(thumbnail, "thumbnails")
+        thumbnail_base64 = encode_image(thumb_path)
+
+        return {
+            "dimensions": (width, height),
+            "mode": mode,
+            "color_analysis": color_analysis,
+            "thumbnail": thumbnail_base64,
+        }
     except Exception as e:
-        logger.error("analyze_image failed: %s", str(e))
-        return tool_response(False, error=f"Image analysis error: {e}")
+        return {"error": str(e)}
 
 
 @tool
-def transform_image(image_path: str, operation: str):
-    """Apply a simple transform (grayscale, blur, sharpen)."""
-    logger.info("transform_image called with image_path=%s operation=%s", image_path, operation)
+def transform_image(
+    image_base64: str, operation: str, params: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """
+    Apply transformations: resize, rotate, crop, flip, brightness, contrast, blur, sharpen, grayscale.
+    Args:
+        image_base64 (str): Base64 encoded input image
+        operation (str): Transformation operation
+        params (Dict[str, Any], optional): Parameters for the operation
+    Returns:
+        Dictionary with transformed image (base64)
+    """
     try:
-        img = Image.open(image_path)
-        if operation == "grayscale":
-            img = img.convert("L")
+        img = decode_image(image_base64)
+        params = params or {}
+
+        if operation == "resize":
+            img = img.resize(
+                (
+                    params.get("width", img.width // 2),
+                    params.get("height", img.height // 2),
+                )
+            )
+        elif operation == "rotate":
+            img = img.rotate(params.get("angle", 90), expand=True)
+        elif operation == "crop":
+            img = img.crop(
+                (
+                    params.get("left", 0),
+                    params.get("top", 0),
+                    params.get("right", img.width),
+                    params.get("bottom", img.height),
+                )
+            )
+        elif operation == "flip":
+            if params.get("direction", "horizontal") == "horizontal":
+                img = img.transpose(Image.FLIP_LEFT_RIGHT)
+            else:
+                img = img.transpose(Image.FLIP_TOP_BOTTOM)
+        elif operation == "adjust_brightness":
+            img = ImageEnhance.Brightness(img).enhance(params.get("factor", 1.5))
+        elif operation == "adjust_contrast":
+            img = ImageEnhance.Contrast(img).enhance(params.get("factor", 1.5))
         elif operation == "blur":
-            img = img.filter(ImageFilter.BLUR)
+            img = img.filter(ImageFilter.GaussianBlur(params.get("radius", 2)))
         elif operation == "sharpen":
             img = img.filter(ImageFilter.SHARPEN)
+        elif operation == "grayscale":
+            img = img.convert("L")
         else:
-            raise ValueError(f"Unsupported operation: {operation}")
-        output_path = f"transformed_{uuid.uuid4()}.png"
-        img.save(output_path)
-        return tool_response(True, output_path)
+            return {"error": f"Unknown operation: {operation}"}
+
+        result_path = save_image(img)
+        result_base64 = encode_image(result_path)
+        return {"transformed_image": result_base64}
+
     except Exception as e:
-        logger.error("transform_image failed: %s", str(e))
-        return tool_response(False, error=f"Transform error: {e}")
+        return {"error": str(e)}
 
 
 @tool
-def draw_on_image(image_path: str, text: str):
-    """Draw text on an image."""
-    logger.info("draw_on_image called with image_path=%s text=%s", image_path, text)
+def draw_on_image(
+    image_base64: str, drawing_type: str, params: Dict[str, Any]
+) -> Dict[str, Any]:
+    """
+    Draw shapes (rectangle, circle, line) or text onto an image.
+    Args:
+        image_base64 (str): Base64 encoded input image
+        drawing_type (str): Drawing type
+        params (Dict[str, Any]): Drawing parameters
+    Returns:
+        Dictionary with result image (base64)
+    """
     try:
-        img = Image.open(image_path)
+        img = decode_image(image_base64)
         draw = ImageDraw.Draw(img)
-        draw.text((10, 10), text, fill="black")
-        output_path = f"drawn_{uuid.uuid4()}.png"
-        img.save(output_path)
-        return tool_response(True, output_path)
+        color = params.get("color", "red")
+
+        if drawing_type == "rectangle":
+            draw.rectangle(
+                [params["left"], params["top"], params["right"], params["bottom"]],
+                outline=color,
+                width=params.get("width", 2),
+            )
+        elif drawing_type == "circle":
+            x, y, r = params["x"], params["y"], params["radius"]
+            draw.ellipse(
+                (x - r, y - r, x + r, y + r),
+                outline=color,
+                width=params.get("width", 2),
+            )
+        elif drawing_type == "line":
+            draw.line(
+                (
+                    params["start_x"],
+                    params["start_y"],
+                    params["end_x"],
+                    params["end_y"],
+                ),
+                fill=color,
+                width=params.get("width", 2),
+            )
+        elif drawing_type == "text":
+            font_size = params.get("font_size", 20)
+            try:
+                font = ImageFont.truetype("arial.ttf", font_size)
+            except IOError:
+                font = ImageFont.load_default()
+            draw.text(
+                (params["x"], params["y"]),
+                params.get("text", "Text"),
+                fill=color,
+                font=font,
+            )
+        else:
+            return {"error": f"Unknown drawing type: {drawing_type}"}
+
+        result_path = save_image(img)
+        result_base64 = encode_image(result_path)
+        return {"result_image": result_base64}
+
     except Exception as e:
-        logger.error("draw_on_image failed: %s", str(e))
-        return tool_response(False, error=f"Draw error: {e}")
+        return {"error": str(e)}
 
 
 @tool
-def generate_simple_image(text: str):
-    """Generate a simple image with text."""
-    logger.info("generate_simple_image called with text=%s", text)
+def generate_simple_image(
+    image_type: str,
+    width: int = 500,
+    height: int = 500,
+    params: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """
+    Generate a simple image (gradient, noise, pattern, chart).
+    Args:
+        image_type (str): Type of image
+        width (int), height (int)
+        params (Dict[str, Any], optional): Specific parameters
+    Returns:
+        Dictionary with generated image (base64)
+    """
     try:
-        img = Image.new("RGB", (200, 100), color="white")
-        draw = ImageDraw.Draw(img)
-        draw.text((10, 40), text, fill="black")
-        output_path = f"generated_{uuid.uuid4()}.png"
-        img.save(output_path)
-        return tool_response(True, output_path)
+        params = params or {}
+
+        if image_type == "gradient":
+            direction = params.get("direction", "horizontal")
+            start_color = params.get("start_color", (255, 0, 0))
+            end_color = params.get("end_color", (0, 0, 255))
+
+            img = Image.new("RGB", (width, height))
+            draw = ImageDraw.Draw(img)
+
+            if direction == "horizontal":
+                for x in range(width):
+                    r = int(
+                        start_color[0] + (end_color[0] - start_color[0]) * x / width
+                    )
+                    g = int(
+                        start_color[1] + (end_color[1] - start_color[1]) * x / width
+                    )
+                    b = int(
+                        start_color[2] + (end_color[2] - start_color[2]) * x / width
+                    )
+                    draw.line([(x, 0), (x, height)], fill=(r, g, b))
+            else:
+                for y in range(height):
+                    r = int(
+                        start_color[0] + (end_color[0] - start_color[0]) * y / height
+                    )
+                    g = int(
+                        start_color[1] + (end_color[1] - start_color[1]) * y / height
+                    )
+                    b = int(
+                        start_color[2] + (end_color[2] - start_color[2]) * y / height
+                    )
+                    draw.line([(0, y), (width, y)], fill=(r, g, b))
+
+        elif image_type == "noise":
+            noise_array = np.random.randint(0, 256, (height, width, 3), dtype=np.uint8)
+            img = Image.fromarray(noise_array, "RGB")
+
+        else:
+            return {"error": f"Unsupported image_type {image_type}"}
+
+        result_path = save_image(img)
+        result_base64 = encode_image(result_path)
+        return {"generated_image": result_base64}
+
     except Exception as e:
-        logger.error("generate_simple_image failed: %s", str(e))
-        return tool_response(False, error=f"Image generation error: {e}")
+        return {"error": str(e)}
 
 
 @tool
-def combine_images(image1_path: str, image2_path: str):
-    """Combine two images side by side."""
-    logger.info("combine_images called with %s and %s", image1_path, image2_path)
+def combine_images(
+    images_base64: List[str], operation: str, params: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """
+    Combine multiple images (collage, stack, blend).
+    Args:
+        images_base64 (List[str]): List of base64 images
+        operation (str): Combination type
+        params (Dict[str, Any], optional)
+    Returns:
+        Dictionary with combined image (base64)
+    """
     try:
-        img1 = Image.open(image1_path)
-        img2 = Image.open(image2_path)
-        combined = Image.new("RGB", (img1.width + img2.width, max(img1.height, img2.height)))
-        combined.paste(img1, (0, 0))
-        combined.paste(img2, (img1.width, 0))
-        output_path = f"combined_{uuid.uuid4()}.png"
-        combined.save(output_path)
-        return tool_response(True, output_path)
-    except Exception as e:
-        logger.error("combine_images failed: %s", str(e))
-        return tool_response(False, error=f"Combine error: {e}")
+        images = [decode_image(b64) for b64 in images_base64]
+        params = params or {}
+
+        if operation == "stack":
+            direction = params.get("direction", "horizontal")
+            if direction == "horizontal":
+                total_width = sum(img.width for img in images)
+                max_height = max(img.height for img in images)
+                new_img = Image.new("RGB", (total_width, max_height))
+                x = 0
+                for img in images:
+                    new_img.paste(img, (x, 0))
+                    x += img.width
+            else:
+                max_width = max(img.width for img in images)
+                total_height = sum(img.height for img in images)
+                new_img = Image.new("RGB", (max_width, total_height))
+                y = 0
+                for img in images:
+                    new_img.paste(img, (0, y))
+                    y += img.height
+        else:
+            return {"error": f"Unsupported combination operation {operation}"}
 
+        result_path = save_image(new_img)
+        result_base64 = encode_image(result_path)
+        return {"combined_image": result_base64}
+
+    except Exception as e:
+        return {"error": str(e)}
 
 # =========================
 # 📊 Data Tools
@@ -286,7 +559,12 @@ def combine_images(image1_path: str, image2_path: str):
 
 @tool
 def analyze_csv_file(file_path: str):
-    """Analyze a CSV file and return basic info."""
+    """
+    Analyze a CSV file using pandas and answer a question about it.
+    Args:
+        file_path (str): the path to the CSV file.
+        query (str): Question about the data
+    """
     logger.info("analyze_csv_file called with file_path=%s", file_path)
     try:
         df = pd.read_csv(file_path)
@@ -299,7 +577,12 @@ def analyze_csv_file(file_path: str):
 
 @tool
 def analyze_excel_file(file_path: str):
-    """Analyze an Excel file and return basic info."""
+    """
+    Analyze an Excel file using pandas and answer a question about it.
+    Args:
+        file_path (str): the path to the Excel file.
+        query (str): Question about the data
+    """
     logger.info("analyze_excel_file called with file_path=%s", file_path)
     try:
         df = pd.read_excel(file_path)
@@ -315,62 +598,119 @@ def analyze_excel_file(file_path: str):
 # =========================
 
 @tool
-def execute_code_multilang(code: str, language: str = "python"):
-    """Execute code in multiple languages using CodeInterpreter."""
-    logger.info("execute_code_multilang called with language=%s", language)
-    try:
-        result = interpreter_instance.execute_code(code, language)
-        return tool_response(True, result)
-    except Exception as e:
-        logger.error("execute_code_multilang failed: %s", str(e))
-        return tool_response(False, error=f"Code execution error: {e}")
+def execute_code_multilang(code: str, language: str = "python") -> str:
+    """Execute code in multiple languages (Python, Bash, SQL, C, Java) and return results.
+    Args:
+        code (str): The source code to execute.
+        language (str): The language of the code. Supported: "python", "bash", "sql", "c", "java".
+    Returns:
+        A string summarizing the execution results (stdout, stderr, errors, plots, dataframes if any).
+    """
+    supported_languages = ["python", "bash", "sql", "c", "java"]
+    language = language.lower()
+
+    if language not in supported_languages:
+        return f"❌ Unsupported language: {language}. Supported languages are: {', '.join(supported_languages)}"
+
+    result = interpreter_instance.execute_code(code, language=language)
+
+    response = []
+
+    if result["status"] == "success":
+        response.append(f"✅ Code executed successfully in **{language.upper()}**")
+
+        if result.get("stdout"):
+            response.append(
+                "\n**Standard Output:**\n```\n" + result["stdout"].strip() + "\n```"
+            )
+
+        if result.get("stderr"):
+            response.append(
+                "\n**Standard Error (if any):**\n```\n"
+                + result["stderr"].strip()
+                + "\n```"
+            )
+
+        if result.get("result") is not None:
+            response.append(
+                "\n**Execution Result:**\n```\n"
+                + str(result["result"]).strip()
+                + "\n```"
+            )
+
+        if result.get("dataframes"):
+            for df_info in result["dataframes"]:
+                response.append(
+                    f"\n**DataFrame `{df_info['name']}` (Shape: {df_info['shape']})**"
+                )
+                df_preview = pd.DataFrame(df_info["head"])
+                response.append("First 5 rows:\n```\n" + str(df_preview) + "\n```")
+
+        if result.get("plots"):
+            response.append(
+                f"\n**Generated {len(result['plots'])} plot(s)** (Image data returned separately)"
+            )
+
+    else:
+        response.append(f"❌ Code execution failed in **{language.upper()}**")
+        if result.get("stderr"):
+            response.append(
+                "\n**Error Log:**\n```\n" + result["stderr"].strip() + "\n```"
+            )
+
+    return "\n".join(response)
 
 # =========================
 # 🌍 Search Tools
 # =========================
 
 @tool
-def web_search(query: str, max_results: int = 3):
-    """Perform a web search using TavilySearchResults."""
-    logger.info("web_search called with query=%s", query)
-    try:
-        tavily = TavilySearchResults(max_results=max_results)
-        results = tavily.invoke(query)
-        return tool_response(True, results)
-    except Exception as e:
-        logger.error("web_search failed: %s", str(e))
-        return tool_response(False, error=f"Web search error: {e}")
+def web_search(query: str) -> str:
+    """Search Tavily for a query and return maximum 3 results.
+    Args:
+        query: The search query."""
+    search_docs = TavilySearchResults(max_results=3).invoke(query)
+    formatted_search_docs = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.get("url", "")}" title="{doc.get("title", "")}"/>\n{doc.get("content", "")}\n</Document>'
+            for doc in search_docs
+        ]
+    )
+    return {"web_results": formatted_search_docs}
 
 
 @tool
-def wiki_search(query: str):
-    """Search Wikipedia and return documents."""
-    logger.info("wiki_search called with query=%s", query)
-    try:
-        loader = WikipediaLoader(query=query, load_max_docs=3)
-        docs = loader.load()
-        results = [doc.page_content for doc in docs]
-        return tool_response(True, results)
-    except Exception as e:
-        logger.error("wiki_search failed: %s", str(e))
-        return tool_response(False, error=f"Wikipedia error: {e}")
+def wiki_search(query: str) -> str:
+    """Search Wikipedia for a query and return maximum 2 results.
+    Args:
+        query: The search query."""
+    search_docs = WikipediaLoader(query=query, load_max_docs=2).load()
+    formatted_search_docs = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
+            for doc in search_docs
+        ]
+    )
+    return {"wiki_results": formatted_search_docs}
 
 
 @tool
-def arxiv_search(query: str):
-    """Search Arxiv and return documents."""
-    logger.info("arxiv_search called with query=%s", query)
-    try:
-        loader = ArxivLoader(query=query, load_max_docs=3)
-        docs = loader.load()
-        results = [doc.page_content for doc in docs]
-        return tool_response(True, results)
-    except Exception as e:
-        logger.error("arxiv_search failed: %s", str(e))
-        return tool_response(False, error=f"Arxiv error: {e}")
+def arxiv_search(query: str) -> str:
+    """Search Arxiv for a query and return maximum 3 result.
+    Args:
+        query: The search query."""
+    search_docs = ArxivLoader(query=query, load_max_docs=3).load()
+    formatted_search_docs = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content[:1000]}\n</Document>'
+            for doc in search_docs
+        ]
+    )
+    return {"arxiv_results": formatted_search_docs}
+
+
+
 
-if __name__ == "__main__":
-    logger.info("=== Running Tool Tests ===")
 
 
 # =========================
@@ -445,6 +785,7 @@ tools = [
     draw_on_image,
     generate_simple_image,
     combine_images,
+    extract_text_from_audio,
 ]
 
 
@@ -452,9 +793,24 @@ tools = [
 def build_graph(provider: str = "groq"):
     """Build the graph"""
     # Load environment variables from .env file
+    import time
+    import httpx
+    class ChatGroqWithRetry(ChatGroq):
+        def invoke(self, *args, **kwargs):
+            max_retries = 5
+            for attempt in range(max_retries):
+                try:
+                    return super().invoke(*args, **kwargs)
+                except httpx.HTTPStatusError as e:
+                    if e.response.status_code == 429:
+                        wait = min(2 ** attempt, 30)
+                        time.sleep(wait)
+                        continue
+                    raise
+            raise Exception("Groq API: Too Many Requests after retries.")
     if provider == "groq":
         # Groq https://console.groq.com/docs/models
-        llm = ChatGroq(model="qwen/qwen3-32b", temperature=0)
+        llm = ChatGroqWithRetry(model="qwen/qwen3-32b", temperature=0)
     elif provider == "huggingface":
         # TODO: Add huggingface endpoint
         llm = ChatHuggingFace(