Update app.py

app.py

@@ -21,7 +21,7 @@ import requests
 from bs4 import BeautifulSoup
 from markdownify import markdownify as md
 from readability import Document
-from urllib.parse import urljoin, urldefrag, urlparse
+from urllib.parse import urlparse
 from ddgs import DDGS
 from PIL import Image
 from huggingface_hub import InferenceClient
@@ -301,19 +301,26 @@ def Fetch_Webpage(  # <-- MCP tool #1 (Fetch)
             - Clean formatting without navigation/sidebar elements
             - Length controlled by verbosity setting
     """
+    _log_call_start("Fetch_Webpage", url=url, verbosity=verbosity)
     if not url or not url.strip():
-        return "Please enter a valid URL."
+        result = "Please enter a valid URL."
+        _log_call_end("Fetch_Webpage", _truncate_for_log(result))
+        return result
 
     try:
         resp = _http_get_enhanced(url)
         resp.raise_for_status()
     except requests.exceptions.RequestException as e:
-        return f"An error occurred: {e}"
+        result = f"An error occurred: {e}"
+        _log_call_end("Fetch_Webpage", _truncate_for_log(result))
+        return result
 
     final_url = str(resp.url)
     ctype = resp.headers.get("Content-Type", "")
     if "html" not in ctype.lower():
-        return f"Unsupported content type for extraction: {ctype or 'unknown'}"
+        result = f"Unsupported content type for extraction: {ctype or 'unknown'}"
+        _log_call_end("Fetch_Webpage", _truncate_for_log(result))
+        return result
 
     # Decode to text
     resp.encoding = resp.encoding or resp.apparent_encoding
@@ -325,11 +332,13 @@ def Fetch_Webpage(  # <-- MCP tool #1 (Fetch)
     
     # Apply verbosity-based truncation
     if verbosity == "Brief":
-        return _truncate_markdown(markdown_content, 1000)
+        result = _truncate_markdown(markdown_content, 1000)
     elif verbosity == "Standard":
-        return _truncate_markdown(markdown_content, 3000)
+        result = _truncate_markdown(markdown_content, 3000)
     else:  # "Full"
-        return markdown_content
+        result = markdown_content
+    _log_call_end("Fetch_Webpage", f"markdown_chars={len(result)}")
+    return result
 
 
 # ============================================
@@ -364,6 +373,51 @@ class RateLimiter:
 _search_rate_limiter = RateLimiter(requests_per_minute=20)
 _fetch_rate_limiter = RateLimiter(requests_per_minute=25)
 
+# ==============================
+# Logging Helpers (print I/O to terminal)
+# ==============================
+
+def _truncate_for_log(value: str, limit: int = 500) -> str:
+    """Truncate long strings for concise terminal logging."""
+    if len(value) <= limit:
+        return value
+    return value[:limit - 1] + "…"
+
+
+def _serialize_input(val):  # type: ignore[return-any]
+    """Best-effort compact serialization of arbitrary input values for logging."""
+    try:
+        if isinstance(val, (str, int, float, bool)) or val is None:
+            return val
+        if isinstance(val, (list, tuple)):
+            return [_serialize_input(v) for v in list(val)[:10]] + (["…"] if len(val) > 10 else [])  # type: ignore[index]
+        if isinstance(val, dict):
+            out = {}
+            for i, (k, v) in enumerate(val.items()):
+                if i >= 12:
+                    out["…"] = "…"
+                    break
+                out[str(k)] = _serialize_input(v)
+            return out
+        return repr(val)[:120]
+    except Exception:
+        return "<unserializable>"
+
+
+def _log_call_start(func_name: str, **kwargs) -> None:
+    try:
+        compact = {k: _serialize_input(v) for k, v in kwargs.items()}
+        print(f"[TOOL CALL] {func_name} inputs: {json.dumps(compact, ensure_ascii=False)[:800]}", flush=True)
+    except Exception as e:  # pragma: no cover - logging safety
+        print(f"[TOOL CALL] {func_name} (failed to log inputs: {e})", flush=True)
+
+
+def _log_call_end(func_name: str, output_desc: str) -> None:
+    try:
+        print(f"[TOOL RESULT] {func_name} output: {output_desc}", flush=True)
+    except Exception as e:  # pragma: no cover
+        print(f"[TOOL RESULT] {func_name} (failed to log output: {e})", flush=True)
+
 def Search_DuckDuckGo(  # <-- MCP tool #2 (DDG Search)
     query: Annotated[str, "The search query (supports operators like site:, quotes, OR)."],
     max_results: Annotated[int, "Number of results to return (1–20)."] = 5,
@@ -385,8 +439,11 @@ def Search_DuckDuckGo(  # <-- MCP tool #2 (DDG Search)
     Returns:
         str: Search results in readable format with titles, URLs, and snippets as a numbered list.
     """
+    _log_call_start("Search_DuckDuckGo", query=query, max_results=max_results)
     if not query or not query.strip():
-        return "No search query provided. Please enter a search term."
+        result = "No search query provided. Please enter a search term."
+        _log_call_end("Search_DuckDuckGo", _truncate_for_log(result))
+        return result
 
     # Validate max_results
     max_results = max(1, min(20, max_results))
@@ -407,11 +464,14 @@ def Search_DuckDuckGo(  # <-- MCP tool #2 (DDG Search)
             error_msg = "Search timed out. Please try again with a simpler query."
         elif "network" in str(e).lower() or "connection" in str(e).lower():
             error_msg = "Network connection error. Please check your internet connection and try again."
-            
-        return f"Error: {error_msg}"
+        result = f"Error: {error_msg}"
+        _log_call_end("Search_DuckDuckGo", _truncate_for_log(result))
+        return result
 
     if not raw:
-        return f"No results found for query: {query}"
+        result = f"No results found for query: {query}"
+        _log_call_end("Search_DuckDuckGo", _truncate_for_log(result))
+        return result
 
     results = []
 
@@ -432,7 +492,9 @@ def Search_DuckDuckGo(  # <-- MCP tool #2 (DDG Search)
         results.append(result_obj)
 
     if not results:
-        return f"No valid results found for query: {query}"
+        result = f"No valid results found for query: {query}"
+        _log_call_end("Search_DuckDuckGo", _truncate_for_log(result))
+        return result
 
     # Format output in readable format
     lines = [f"Found {len(results)} search results for: {query}\n"]
@@ -442,7 +504,9 @@ def Search_DuckDuckGo(  # <-- MCP tool #2 (DDG Search)
         if result['snippet']:
             lines.append(f"   Summary: {result['snippet']}")
         lines.append("")  # Empty line between results
-    return "\n".join(lines)
+    result = "\n".join(lines)
+    _log_call_end("Search_DuckDuckGo", f"results={len(results)} chars={len(result)}")
+    return result
 
 
 # ======================================
@@ -460,18 +524,23 @@ def Execute_Python(code: Annotated[str, "Python source code to run; stdout is ca
         str: Combined stdout produced by the code, or the exception text if
         execution failed.
     """
+    _log_call_start("Execute_Python", code=_truncate_for_log(code or "", 300))
     if code is None:
-        return "No code provided."
+        result = "No code provided."
+        _log_call_end("Execute_Python", result)
+        return result
 
     old_stdout = sys.stdout
     redirected_output = sys.stdout = StringIO()
     try:
         exec(code)
-        return redirected_output.getvalue()
+        result = redirected_output.getvalue()
     except Exception as e:
-        return str(e)
+        result = str(e)
     finally:
         sys.stdout = old_stdout
+    _log_call_end("Execute_Python", _truncate_for_log(result))
+    return result
 
 
 # ==========================
@@ -637,7 +706,12 @@ def Generate_Speech(  # <-- MCP tool #4 (Generate Speech)
         - Can generate audio of any length - no 30 second limit!
         - Use List_Kokoro_Voices() MCP tool to discover all available voice options.
     """
+    _log_call_start("Generate_Speech", text=_truncate_for_log(text, 200), speed=speed, voice=voice)
     if not text or not text.strip():
+        try:
+            _log_call_end("Generate_Speech", "error=empty text")
+        finally:
+            pass
         raise gr.Error("Please provide non-empty text to synthesize.")
 
     _init_kokoro()
@@ -651,29 +725,29 @@ def Generate_Speech(  # <-- MCP tool #4 (Generate Speech)
     # Process ALL segments for longer audio generation
     audio_segments = []
     pack = pipeline.load_voice(voice)
-    
+
     try:
         # Get all segments first to show progress for long text
         segments = list(pipeline(text, voice, speed))
         total_segments = len(segments)
-        
+
         # Iterate through ALL segments instead of just the first one
         for segment_idx, (text_chunk, ps, _) in enumerate(segments):
             ref_s = pack[len(ps) - 1]
             try:
                 audio = model(ps, ref_s, float(speed))
                 audio_segments.append(audio.detach().cpu().numpy())
-                
+
                 # For very long text (>10 segments), show progress every few segments
                 if total_segments > 10 and (segment_idx + 1) % 5 == 0:
                     print(f"Progress: Generated {segment_idx + 1}/{total_segments} segments...")
-                    
+
             except Exception as e:
                 raise gr.Error(f"Error generating audio for segment {segment_idx + 1}: {str(e)}")
-        
+
         if not audio_segments:
             raise gr.Error("No audio was generated (empty synthesis result).")
-        
+
         # Concatenate all segments to create the complete audio
         if len(audio_segments) == 1:
             final_audio = audio_segments[0]
@@ -683,13 +757,16 @@ def Generate_Speech(  # <-- MCP tool #4 (Generate Speech)
             duration = len(final_audio) / 24_000
             if total_segments > 1:
                 print(f"Completed: {total_segments} segments concatenated into {duration:.1f} seconds of audio")
-            
-        # Return 24 kHz mono waveform
+
+        # Success logging & return
+        _log_call_end("Generate_Speech", f"samples={final_audio.shape[0]} duration_sec={len(final_audio)/24_000:.2f}")
         return 24_000, final_audio
-        
-    except gr.Error:
-        raise  # Re-raise Gradio errors as-is
+
+    except gr.Error as e:
+        _log_call_end("Generate_Speech", f"gr_error={str(e)}")
+        raise  # Re-raise
     except Exception as e:
+        _log_call_end("Generate_Speech", f"error={str(e)[:120]}")
         raise gr.Error(f"Error during speech generation: {str(e)}")
 
 
@@ -884,7 +961,9 @@ def Generate_Image(  # <-- MCP tool #5 (Generate Image)
     Error modes:
         - Raises gr.Error with a user-friendly message on auth/model/load errors.
     """
+    _log_call_start("Generate_Image", prompt=_truncate_for_log(prompt, 200), model_id=model_id, steps=steps, cfg_scale=cfg_scale, seed=seed, size=f"{width}x{height}")
     if not prompt or not prompt.strip():
+        _log_call_end("Generate_Image", "error=empty prompt")
         raise gr.Error("Please provide a non-empty prompt.")
 
     # Slightly enhance prompt for quality (kept consistent with Serverless space)
@@ -907,6 +986,7 @@ def Generate_Image(  # <-- MCP tool #5 (Generate Image)
                 guidance_scale=cfg_scale,
                 seed=seed if seed != -1 else random.randint(1, 1_000_000_000),
             )
+            _log_call_end("Generate_Image", f"provider={provider} size={image.size}")
             return image
         except Exception as e:  # try next provider, transform last one to friendly error
             last_error = e
@@ -920,6 +1000,7 @@ def Generate_Image(  # <-- MCP tool #5 (Generate Image)
         raise gr.Error("The model is warming up. Please try again shortly.")
     if "401" in msg or "403" in msg:
         raise gr.Error("Authentication failed. Set HF_READ_TOKEN environment variable with access to the model.")
+    _log_call_end("Generate_Image", f"error={_truncate_for_log(msg, 200)}")
     raise gr.Error(f"Image generation failed: {msg}")
 
 
@@ -1038,7 +1119,9 @@ def Generate_Video(  # <-- MCP tool #6 (Generate Video)
     Error modes:
         - Raises gr.Error with a user-friendly message on auth/model/load errors or unsupported parameters.
     """
+    _log_call_start("Generate_Video", prompt=_truncate_for_log(prompt, 160), model_id=model_id, steps=steps, cfg_scale=cfg_scale, fps=fps, duration=duration, size=f"{width}x{height}")
     if not prompt or not prompt.strip():
+        _log_call_end("Generate_Video", "error=empty prompt")
         raise gr.Error("Please provide a non-empty prompt.")
 
     if not HF_VIDEO_TOKEN:
@@ -1103,6 +1186,11 @@ def Generate_Video(  # <-- MCP tool #6 (Generate Video)
 
             # Save output to an .mp4
             path = _write_video_tmp(result, suffix=".mp4")
+            try:
+                size = os.path.getsize(path)
+            except Exception:
+                size = -1
+            _log_call_end("Generate_Video", f"provider={provider} path={os.path.basename(path)} bytes={size}")
             return path
         except Exception as e:
             last_error = e
@@ -1115,6 +1203,7 @@ def Generate_Video(  # <-- MCP tool #6 (Generate Video)
         raise gr.Error("The model is warming up. Please try again shortly.")
     if "401" in msg or "403" in msg:
         raise gr.Error("Authentication failed or not permitted. Set HF_READ_TOKEN/HF_TOKEN with inference access.")
+    _log_call_end("Generate_Video", f"error={_truncate_for_log(msg, 200)}")
     raise gr.Error(f"Video generation failed: {msg}")