Fixed broken main

README.md

@@ -493,27 +493,46 @@ The codebase follows a clean modular design with clear separation of concerns:
 
 ### Tab Modules (`agent_ng/tabs/`)
 
-- **`chat_tab.py`**: Main chat interface tab with quick actions and i18n support
-- **`logs_tab.py`**: Logs and debugging tab with real-time updates
-- **`stats_tab.py`**: Statistics and monitoring tab with live metrics
+- **`chat_tab.py`**: Main chat interface tab with streaming responses, quick action buttons, file upload support, and full i18n support (English/Russian)
+- **`logs_tab.py`**: Real-time debugging and logs tab with live updates, categorized log streams, and session-specific debug output
+- **`stats_tab.py`**: Performance metrics and statistics dashboard with live monitoring, token usage tracking, and LLM provider analytics
+- **`config_tab.py`**: Configuration and settings tab for LLM provider selection, language settings, and system parameters
+- **`home_tab.py`**: Welcome and overview tab with quick start guides, feature highlights, and system status
+- **`sidebar.py`**: Navigation sidebar component with tab switching, user session info, and quick access controls
 
 ### Tool Modules (`tools/`)
 
-- **`tools.py`**: Core tool functions and consolidated tool definitions with 20+ tools
-- **`applications_tools/`**: Application and template management tools
-  - `tool_list_applications.py`: List platform applications
-  - `tool_list_templates.py`: List application templates
-  - `tool_platform_entity_url.py`: Generate platform entity URLs
-- **`attributes_tools/`**: Attribute management tools for all attribute types
-  - Text, Boolean, DateTime, Decimal, Document, Drawing, Duration, Image, Record, Role, Account, Enum attributes
-  - Delete, archive/unarchive, and retrieve attribute operations
-- **`templates_tools/`**: Template-related tools and operations
-  - `tool_list_attributes.py`: List template attributes
-- **`tool_utils.py`**: Common tool utilities and helpers
-- **`models.py`**: Data models and schemas for tools
-- **`requests_.py`**: HTTP request utilities and helpers
-- **`file_utils.py`**: File handling utilities with security
-- **`pdf_utils.py`**: PDF processing utilities with OCR support
+- **`tools.py`**: Core tool functions and consolidated tool definitions with 20+ specialized tools including:
+  - **Math Tools**: Basic arithmetic operations (add, subtract, multiply, divide, power, square root)
+  - **Web Search Tools**: Tavily web search, Wikipedia search, Arxiv academic papers, Exa AI deep research
+  - **File Analysis Tools**: Text file reading, CSV/Excel analysis with pandas, image analysis and OCR
+  - **Code Execution**: Multi-language code interpreter (Python, Bash, SQL, C, Java) with safety controls
+  - **Image Processing**: Image generation, transformation, drawing, and combination tools
+  - **Video/Audio Understanding**: Gemini-powered video and audio analysis with timestamp support
+  - **Data Processing**: Advanced pandas-based data analysis with query support and visualization
+
+- **`applications_tools/`**: CMW Platform application and template management
+  - `tool_list_applications.py`: List and manage platform applications
+  - `tool_list_templates.py`: List application templates and their configurations
+  - `tool_platform_entity_url.py`: Generate direct URLs to platform entities
+
+- **`attributes_tools/`**: Comprehensive attribute management for all CMW Platform attribute types
+  - **Core Attribute Types**: Text, Boolean, DateTime, Decimal/Numeric, Document, Drawing, Duration, Image, Record, Role, Account, Enum
+  - **Management Operations**: Create, edit, delete, archive/unarchive, and retrieve attributes
+  - **Specialized Tools**: Each attribute type has dedicated creation and management tools
+  - **Utility Functions**: Common attribute operations and validation helpers
+
+- **`templates_tools/`**: Template-related operations and management
+  - `tool_list_attributes.py`: List and analyze template attributes
+  - `tools_record_template.py`: Create and manage record templates
+  - Template configuration and relationship management
+
+- **Utility Modules**:
+  - **`tool_utils.py`**: Common tool utilities, validation, and helper functions
+  - **`models.py`**: Pydantic data models and schemas for tool operations
+  - **`requests_.py`**: HTTP request utilities with retry logic and error handling
+  - **`file_utils.py`**: Secure file handling utilities with session isolation and MIME detection
+  - **`pdf_utils.py`**: PDF processing utilities with OCR support and text extraction
 
 ### Key Benefits
 

agent_ng/_tests/test_analyze_tools.py

@@ -0,0 +1,88 @@
+import json
+import sys
+from pathlib import Path
+import pandas as pd
+import pytest
+
+# Ensure project root is on sys.path to import tools
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+import tools.tools as t  # noqa: E402
+
+
+def write_csv(tmp_path: Path) -> Path:
+    df = pd.DataFrame({
+        "A": [1, 2, 3, 4],
+        "B": [0.5, 1.5, 2.5, 3.5],
+        "C": ["x", "y", "x", "z"],
+    })
+    p = tmp_path / "sample.csv"
+    df.to_csv(p, index=False)
+    return p
+
+
+def write_excel(tmp_path: Path) -> Path:
+    df = pd.DataFrame({
+        "A": [10, 20, 30, 40],
+        "B": [5, 15, 25, 35],
+        "C": ["u", "v", "u", "w"],
+    })
+    p = tmp_path / "sample.xlsx"
+    try:
+        df.to_excel(p, index=False)
+    except Exception as e:  # pragma: no cover
+        pytest.skip(f"Excel engine not available: {e}")
+    return p
+
+
+def parse_tool_response(s: str):
+    return json.loads(s)
+
+
+def test_helper_empty_query_preview():
+    df = pd.DataFrame({
+        "A": [1, 2, 3, 4],
+        "B": [0.5, 1.5, 2.5, 3.5],
+        "C": ["x", "y", "x", "z"],
+    })
+    _, payload = t._apply_pandas_query(df, query=None, preview_opts=None, plot_opts=None)
+    assert payload.get("table_markdown")
+    assert payload.get("schema")
+
+
+def test_helper_expr_query():
+    df = pd.DataFrame({
+        "A": [1, 2, 3, 4],
+        "B": [0.5, 1.5, 2.5, 3.5],
+        "C": ["x", "y", "x", "z"],
+    })
+    _, payload = t._apply_pandas_query(df, query="expr: B > 1.0", preview_opts=None, plot_opts=None)
+    assert payload.get("table_markdown")
+
+
+def test_helper_pipeline_query():
+    df = pd.DataFrame({
+        "A": [1, 2, 3, 4],
+        "B": [0.5, 1.5, 2.5, 3.5],
+        "C": ["x", "y", "x", "z"],
+    })
+    pipeline = json.dumps([
+        {"op": "query", "expr": "B > 1.0"},
+        {"op": "head", "n": 2},
+    ])
+    _, payload = t._apply_pandas_query(df, query=pipeline, preview_opts=None, plot_opts=None)
+    assert payload.get("table_markdown")
+
+
+def test_helper_preview_includes_shape_and_schema():
+    df = pd.DataFrame({
+        "A": [1, 2, 3, 4],
+        "B": [0.5, 1.5, 2.5, 3.5],
+    })
+    _, payload = t._apply_pandas_query(df, query=None, preview_opts=None, plot_opts=None)
+    assert "shape" in payload and isinstance(payload["shape"], tuple)
+    assert "schema" in payload and isinstance(payload["schema"], dict)
+
+

agent_ng/app_ng_modular.py

@@ -628,11 +628,13 @@ class NextGenApp:
                 and user_agent.llm_instance
             ):
                 llm_info = user_agent.get_llm_info()
-                print(
-                    f"🔍 DEBUG: Using session agent with LLM: {llm_info.get('provider', 'unknown')}/{llm_info.get('model_name', 'unknown')}"
+                session_debug = get_debug_streamer(session_id)
+                session_debug.debug(
+                    f"Using session agent with LLM: {llm_info.get('provider', 'unknown')}/{llm_info.get('model_name', 'unknown')}"
                 )
             else:
-                print("❌ DEBUG: Session agent has no LLM instance!")
+                session_debug = get_debug_streamer(session_id)
+                session_debug.warning("Session agent has no LLM instance!")
 
             # Use session-specific debug streamer
             session_debug = get_debug_streamer(session_id)

agent_ng/langchain_memory.py

@@ -324,9 +324,6 @@ class LangChainConversationChain:
             if not system_in_history:
                 # Store system message in memory only once
                 self.memory_manager.add_message(conversation_id, system_message)
-                print("🔍 DEBUG: Added system message to memory (first time)")
-            else:
-                print("🔍 DEBUG: System message already in memory, skipping storage")
             
             # Add conversation history (excluding system messages to avoid duplication)
             non_system_history = [msg for msg in chat_history if not isinstance(msg, SystemMessage)]
@@ -377,37 +374,25 @@ class LangChainConversationChain:
             if tool_key in duplicate_counts:
                 # Increment count for duplicate
                 duplicate_counts[tool_key] += 1
-                print(f"🔍 DEBUG: Found duplicate tool call {tool_name} (total count: {duplicate_counts[tool_key]})")
             else:
                 # First occurrence - add to unique list and initialize count
                 unique_tool_calls.append(tool_call)
                 duplicate_counts[tool_key] = 1
-                print(f"🔍 DEBUG: Added unique tool call {tool_name}")
         
         return unique_tool_calls, duplicate_counts
 
     def _track_token_usage(self, response, messages, conversation_id: str = "default"):
         """Track token usage for LLM response"""
         try:
-            print(f"🔍 DEBUG: _track_token_usage called with response type: {type(response)}")
-            print(f"🔍 DEBUG: Has agent: {hasattr(self, 'agent')}")
-            if hasattr(self, 'agent'):
-                print(f"🔍 DEBUG: Agent is not None: {self.agent is not None}")
-                if self.agent:
-                    print(f"🔍 DEBUG: Agent has token_tracker: {hasattr(self.agent, 'token_tracker')}")
-            
             # Get token tracker from the agent
             if hasattr(self, 'agent') and self.agent and hasattr(self.agent, 'token_tracker'):
-                print("🔍 DEBUG: Using agent's token tracker")
                 self.agent.token_tracker.track_llm_response(response, messages)
             else:
-                print("🔍 DEBUG: Creating new token tracker")
                 # Create a simple token tracker if none exists
                 from .token_counter import get_token_tracker
                 token_tracker = get_token_tracker(conversation_id)
                 token_tracker.track_llm_response(response, messages)
         except Exception as e:
-            print(f"🔍 DEBUG: Token tracking error: {e}")
             # Silently fail - token counting is not critical
             pass
     

tools/file_utils.py

@@ -48,6 +48,7 @@ class ToolResponse(BaseModel):
     result: Optional[str] = Field(None, description="Tool result content")
     error: Optional[str] = Field(None, description="Error message if tool failed")
     file_info: Optional[FileInfo] = Field(None, description="File information if applicable")
+    extra: Optional[Dict[str, Any]] = Field(None, description="Optional structured payload for tool-specific data")
 
 class FileUtils:
     """Utility class for common file operations."""
@@ -167,7 +168,7 @@ class FileUtils:
 
     @staticmethod
     def create_tool_response(tool_name: str, result: str = None, error: str = None, 
-                           file_info: FileInfo = None) -> str:
+                           file_info: FileInfo = None, extra: Dict[str, Any] = None) -> str:
         """Create standardized tool response JSON with Pydantic validation."""
         # Sanitize file_info to remove full paths
         if file_info:
@@ -187,7 +188,8 @@ class FileUtils:
             tool_name=tool_name,
             result=result,  # Full result, no truncation
             error=error,
-            file_info=sanitized_file_info
+            file_info=sanitized_file_info,
+            extra=extra
         )
 
         return response.model_dump_json(indent=2)
@@ -583,4 +585,253 @@ class FileUtils:
     @staticmethod
     def is_pdf_file(file_path: str) -> bool:
         """Check if file is likely a PDF file based on extension."""
-        return Path(file_path).suffix.lower() == '.pdf'
+        return Path(file_path).suffix.lower() == '.pdf'
+
+    @staticmethod
+    def get_mime_type(file_path: str) -> str:
+        """Get MIME type for a file based on extension and content."""
+        import mimetypes
+
+        mime_type, _ = mimetypes.guess_type(file_path)
+        if mime_type:
+            return mime_type
+
+        ext = Path(file_path).suffix.lower()
+        mime_map = {
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.webp': 'image/webp',
+            '.svg': 'image/svg+xml',
+            '.tiff': 'image/tiff',
+            '.bmp': 'image/bmp',
+            '.mp4': 'video/mp4',
+            '.webm': 'video/webm',
+            '.avi': 'video/x-msvideo',
+            '.mov': 'video/quicktime',
+            '.wav': 'audio/wav',
+            '.mp3': 'audio/mpeg',
+            '.ogg': 'audio/ogg',
+            '.flac': 'audio/flac',
+            '.aac': 'audio/aac',
+            '.m4a': 'audio/mp4',
+            '.html': 'text/html',
+            '.htm': 'text/html',
+            '.json': 'application/json',
+            '.xml': 'application/xml',
+            '.pdf': 'application/pdf'
+        }
+
+        return mime_map.get(ext, 'application/octet-stream')
+
+    @staticmethod
+    def detect_media_type(file_path: str) -> str:
+        """Detect media type category for a file."""
+        if FileUtils.is_image_file(file_path):
+            return 'image'
+        elif FileUtils.is_video_file(file_path):
+            return 'video'
+        elif FileUtils.is_audio_file(file_path):
+            return 'audio'
+        elif Path(file_path).suffix.lower() == '.html':
+            return 'html'
+        elif Path(file_path).suffix.lower() in ['.png', '.svg'] and 'plot' in file_path.lower():
+            return 'plot'
+        else:
+            return 'unknown'
+
+    @staticmethod
+    def create_media_attachment(file_path: str, caption: str = None, metadata: Dict[str, Any] = None) -> Dict[str, Any]:
+        """
+        Create a media attachment dictionary for rich content.
+
+        Args:
+            file_path: Path to the media file
+            caption: Optional caption for the media
+            metadata: Optional metadata dictionary
+
+        Returns:
+            Dict with media attachment information
+        """
+        if not FileUtils.file_exists(file_path):
+            return {
+                "type": "error",
+                "error": f"File not found: {file_path}"
+            }
+
+        file_info = FileUtils.get_file_info(file_path)
+        media_type = FileUtils.detect_media_type(file_path)
+        mime_type = FileUtils.get_mime_type(file_path)
+
+        attachment = {
+            "type": "media_attachment",
+            "media_type": media_type,
+            "file_path": file_path,
+            "mime_type": mime_type,
+            "file_info": file_info.dict() if file_info else None
+        }
+
+        if caption:
+            attachment["caption"] = caption
+
+        if metadata:
+            attachment["metadata"] = metadata
+
+        return attachment
+
+    @staticmethod
+    def add_media_to_response(tool_response: Dict[str, Any], file_path: str, 
+                            caption: str = None, metadata: Dict[str, Any] = None) -> Dict[str, Any]:
+        """
+        Add media attachment to an existing tool response.
+
+        Args:
+            tool_response: Existing tool response dictionary
+            file_path: Path to the media file
+            caption: Optional caption for the media
+            metadata: Optional metadata dictionary
+
+        Returns:
+            Updated tool response with media attachment
+        """
+        if "media_attachments" not in tool_response:
+            tool_response["media_attachments"] = []
+
+        media_attachment = FileUtils.create_media_attachment(file_path, caption, metadata)
+        tool_response["media_attachments"].append(media_attachment)
+
+        return tool_response
+
+    @staticmethod
+    def extract_media_from_response(tool_response: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """
+        Extract media attachments from a tool response.
+
+        Args:
+            tool_response: Tool response dictionary
+
+        Returns:
+            List of media attachment dictionaries
+        """
+        media_attachments = []
+
+        if "media_attachments" in tool_response:
+            media_attachments.extend(tool_response["media_attachments"])
+
+        if "result" in tool_response and isinstance(tool_response["result"], dict):
+            result = tool_response["result"]
+            for key, value in result.items():
+                if isinstance(value, str) and FileUtils.file_exists(value):
+                    media_attachment = FileUtils.create_media_attachment(value, f"File: {key}")
+                    media_attachments.append(media_attachment)
+
+        return media_attachments
+
+    @staticmethod
+    def is_base64_image(data: str) -> bool:
+        """Check if string contains base64 image data."""
+        import base64
+
+        if data.startswith('data:image/'):
+            return True
+
+        if len(data) > 100:
+            try:
+                clean_data = ''.join(data.split())
+                decoded = base64.b64decode(clean_data)
+                image_magic = [
+                    b'\x89PNG\r\n\x1a\n',
+                    b'\xff\xd8\xff',
+                    b'GIF87a',
+                    b'GIF89a',
+                    b'RIFF',
+                    b'BM'
+                ]
+                return any(decoded.startswith(magic) for magic in image_magic)
+            except:
+                return False
+
+        return False
+
+    @staticmethod
+    def save_base64_to_file(base64_data: str, output_path: str = None, 
+                          file_extension: str = None, session_id: str = None) -> str:
+        """
+        Save base64 data to a file.
+
+        Args:
+            base64_data: Base64 encoded data (with or without data URI prefix)
+            output_path: Optional output file path
+            file_extension: Optional file extension for temp file
+            session_id: Optional session ID to save in session-isolated directory
+
+        Returns:
+            Path to the saved file
+        """
+        import base64
+        import tempfile
+        import uuid
+        import mimetypes
+        from datetime import datetime
+
+        if base64_data.startswith('data:'):
+            header, data = base64_data.split(',', 1)
+            mime_type = header.split(':')[1].split(';')[0]
+            if not file_extension:
+                file_extension = mimetypes.guess_extension(mime_type) or '.bin'
+        else:
+            data = base64_data
+            if not file_extension:
+                file_extension = '.bin'
+
+        if not output_path:
+            if session_id:
+                session_dir = Path(f".gradio/sessions/{session_id}")
+                session_dir.mkdir(parents=True, exist_ok=True)
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                unique_id = str(uuid.uuid4())[:8]
+                filename = f"llm_image_{timestamp}_{unique_id}{file_extension}"
+                output_path = str(session_dir / filename)
+            else:
+                temp_fd, output_path = tempfile.mkstemp(suffix=file_extension)
+                os.close(temp_fd)
+
+        decoded_data = base64.b64decode(data)
+        with open(output_path, 'wb') as f:
+            f.write(decoded_data)
+        return output_path
+
+    @staticmethod
+    def create_gallery_attachment(image_paths: List[str], captions: List[str] = None) -> Dict[str, Any]:
+        """
+        Create a gallery attachment for multiple images.
+
+        Args:
+            image_paths: List of image file paths
+            captions: Optional list of captions for each image
+
+        Returns:
+            Gallery attachment dictionary
+        """
+        if not image_paths:
+            return {"type": "error", "error": "No image paths provided"}
+
+        valid_images = []
+        for i, path in enumerate(image_paths):
+            if FileUtils.file_exists(path) and FileUtils.is_image_file(path):
+                image_info = {
+                    "path": path,
+                    "caption": captions[i] if captions and i < len(captions) else None
+                }
+                valid_images.append(image_info)
+
+        if not valid_images:
+            return {"type": "error", "error": "No valid image files found"}
+
+        return {
+            "type": "gallery_attachment",
+            "media_type": "gallery",
+            "images": valid_images,
+            "count": len(valid_images)
+        }

tools/tools.py

@@ -898,6 +898,182 @@ def extract_text_from_image(file_reference: str, agent=None) -> str:
     except Exception as e:
         return FileUtils.create_tool_response("extract_text_from_image", error=f"Error extracting text from image: {str(e)}")
 
+# ========== PANDAS QUERY/PIPELINE HELPERS ==========
+def _safe_to_markdown(df: pd.DataFrame, max_rows: int = 10, max_cols: int = 20) -> str:
+    preview_df = df.head(max_rows)
+    if max_cols is not None:
+        preview_df = preview_df.iloc[:, :max_cols]
+    try:
+        return preview_df.to_markdown(index=False)
+    except Exception:
+        return preview_df.to_string(index=False)
+
+
+def _dataframe_schema(df: pd.DataFrame) -> Dict[str, str]:
+    return {str(col): str(dtype) for col, dtype in df.dtypes.items()}
+
+
+def _truncate_records(df: pd.DataFrame, max_rows: int = 100, max_cols: int = 50, max_cell_chars: int = 500) -> List[Dict[str, Any]]:
+    limited = df.head(max_rows)
+    if max_cols is not None:
+        limited = limited.iloc[:, :max_cols]
+    def _truncate_val(v: Any) -> Any:
+        try:
+            s = str(v)
+        except Exception:
+            return v
+        if len(s) > max_cell_chars:
+            return s[: max_cell_chars - 1] + "…"
+        return v
+    return [{k: _truncate_val(v) for k, v in row.items()} for row in limited.to_dict(orient="records")]
+
+
+_ALLOWED_OPS: Dict[str, Literal["df_method", "special"]] = {
+    "query": "df_method",
+    "assign": "df_method",
+    "rename": "df_method",
+    "drop": "df_method",
+    "dropna": "df_method",
+    "fillna": "df_method",
+    "astype": "df_method",
+    "sort_values": "df_method",
+    "head": "df_method",
+    "tail": "df_method",
+    "sample": "df_method",
+    "value_counts": "df_method",
+    "nlargest": "df_method",
+    "nsmallest": "df_method",
+    "reset_index": "df_method",
+    "set_index": "df_method",
+    "pivot_table": "df_method",
+    "melt": "df_method",
+    "stack": "df_method",
+    "unstack": "df_method",
+    "groupby": "special",
+}
+
+
+def _coerce_tabular(obj: Any, step_name: str) -> pd.DataFrame:
+    if isinstance(obj, pd.DataFrame):
+        return obj
+    if isinstance(obj, pd.Series):
+        return obj.to_frame(name=step_name or "value").reset_index()
+    return pd.DataFrame(obj)
+
+
+def _dispatch_pipeline(df: pd.DataFrame, steps: List[Dict[str, Any]]) -> pd.DataFrame:
+    current = df
+    for i, step in enumerate(steps):
+        if not isinstance(step, dict):
+            raise ValueError(f"Pipeline step {i} must be an object")
+        op = step.get("op")
+        if not isinstance(op, str) or op.startswith("__"):
+            raise ValueError(f"Invalid op at step {i}")
+        kind = _ALLOWED_OPS.get(op)
+        if kind is None:
+            raise ValueError(f"Op '{op}' not allowed")
+        if kind == "df_method":
+            method = getattr(current, op, None)
+            if method is None or not callable(method):
+                raise ValueError(f"Method '{op}' not available on DataFrame")
+            kwargs = {k: v for k, v in step.items() if k != "op"}
+            result = method(**kwargs) if kwargs else method()
+            current = _coerce_tabular(result, op)
+        else:
+            if op == "groupby":
+                by = step.get("by")
+                gb = current.groupby(by=by, dropna=False, observed=False)
+                if "agg" in step:
+                    result = gb.agg(step.get("agg"))
+                    current = _coerce_tabular(result, op)
+                elif step.get("size") is True:
+                    current = gb.size().reset_index(name="size")
+                else:
+                    raise ValueError("groupby requires 'agg' or size=true")
+            else:
+                raise ValueError(f"Unsupported special op: {op}")
+    return current
+
+
+def _apply_pandas_query(
+    df: pd.DataFrame,
+    query: Optional[str],
+    preview_opts: Optional[Dict[str, Any]] = None,
+    plot_opts: Optional[Dict[str, Any]] = None,
+) -> Tuple[pd.DataFrame, Dict[str, Any]]:
+    preview = preview_opts or {"rows": 10, "cols": 20, "include_schema": True}
+    plots: List[str] = []
+    original_shape = tuple(df.shape)
+
+    transformed = df
+    if query and isinstance(query, str) and query.strip():
+        q = query.strip()
+        try:
+            if q.startswith("{") and q.endswith("}"):
+                cfg = json.loads(q)
+                if isinstance(cfg.get("pipeline"), list):
+                    transformed = _dispatch_pipeline(df, cfg["pipeline"])  # type: ignore[arg-type]
+                elif isinstance(cfg.get("expr"), str):
+                    transformed = df.query(cfg["expr"])  # type: ignore[arg-type]
+                plot_opts = cfg.get("plot") or plot_opts
+                preview = cfg.get("preview") or preview
+            elif q.startswith("[") and q.endswith("]"):
+                steps = json.loads(q)
+                transformed = _dispatch_pipeline(df, steps)
+            elif q.lower().startswith("expr:"):
+                expr = q.split(":", 1)[1].strip()
+                transformed = df.query(expr)
+            else:
+                transformed = df.query(q)
+        except Exception as e:
+            raise ValueError(f"Failed to apply query: {e}")
+
+    if plot_opts and MATPLOTLIB_AVAILABLE and plt is not None:
+        try:
+            kind = plot_opts.get("kind", "bar")
+            x = plot_opts.get("x")
+            y = plot_opts.get("y")
+            fig = plt.figure()
+            ax = fig.gca()
+            data = transformed
+            if x is None and y is None and kind in ("bar", "barh"):
+                non_numeric = [c for c in data.columns if not pd.api.types.is_numeric_dtype(data[c])]
+                target_col = non_numeric[0] if non_numeric else data.columns[0]
+                vc = data[target_col].value_counts().head(20)
+                vc.plot(kind=kind, ax=ax)
+            else:
+                data.plot(kind=kind, x=x, y=y, ax=ax)
+            plot_path = os.path.join(tempfile.gettempdir(), f"df_plot_{uuid.uuid4().hex}.png")
+            fig.savefig(plot_path, bbox_inches="tight")
+            plt.close(fig)
+            plots.append(encode_image(plot_path))
+        except Exception:
+            pass
+
+    rows = int(preview.get("rows", 10))
+    cols = int(preview.get("cols", 20))
+    include_schema = bool(preview.get("include_schema", True))
+
+    table_markdown = _safe_to_markdown(transformed, rows, cols)
+    table_records = _truncate_records(transformed, max_rows=min(rows, 1000), max_cols=min(cols, 100))
+    payload: Dict[str, Any] = {
+        "original_shape": original_shape,
+        "shape": tuple(transformed.shape),
+        "table_markdown": table_markdown,
+        "table_records": table_records,
+    }
+    if include_schema:
+        payload["schema"] = _dataframe_schema(transformed)
+    try:
+        if transformed.shape[0] <= 5000 and transformed.shape[1] <= 50:
+            payload["describe_summary"] = str(transformed.describe(include="all", datetime_is_numeric=True))
+    except Exception:
+        pass
+    if plots:
+        payload["plots"] = plots
+    return transformed, payload
+
+
 @tool
 def analyze_csv_file(file_reference: str, query: str, agent=None) -> str:
     """
@@ -930,12 +1106,28 @@ def analyze_csv_file(file_reference: str, query: str, agent=None) -> str:
         return FileUtils.create_tool_response("analyze_csv_file", error=file_info.error)
     try:
         df = pd.read_csv(file_path)
-        result = f"CSV file loaded with {len(df)} rows and {len(df.columns)} columns.\n"
-        result += f"File: {file_info.name} ({FileUtils.format_file_size(file_info.size)})\n"
-        result += f"Columns: {', '.join(df.columns)}\n\n"
-        result += "Summary statistics:\n"
-        result += str(df.describe())
-        return FileUtils.create_tool_response("analyze_csv_file", result=result, file_info=file_info)
+        _, payload = _apply_pandas_query(
+            df,
+            query=query if isinstance(query, str) and query.strip() else None,
+            preview_opts=None,
+            plot_opts=None,
+        )
+        header = (
+            f"CSV file loaded with {len(df)} rows and {len(df.columns)} columns.\n"
+            f"File: {file_info.name} ({FileUtils.format_file_size(file_info.size)})\n"
+        )
+        result_parts = [header]
+        if payload.get("table_markdown"):
+            result_parts.append("Preview:\n" + payload["table_markdown"])
+        if payload.get("describe_summary"):
+            result_parts.append("\n\nSummary statistics:\n" + str(payload["describe_summary"]))
+        result_text = "\n".join(result_parts)
+        return FileUtils.create_tool_response(
+            "analyze_csv_file",
+            result=result_text,
+            file_info=file_info,
+            extra=payload,
+        )
     except Exception as e:
         return FileUtils.create_tool_response("analyze_csv_file", error=f"Error analyzing CSV file: {str(e)}")
 
@@ -971,12 +1163,28 @@ def analyze_excel_file(file_reference: str, query: str, agent=None) -> str:
         return FileUtils.create_tool_response("analyze_excel_file", error=file_info.error)
     try:
         df = pd.read_excel(file_path)
-        result = f"Excel file loaded with {len(df)} rows and {len(df.columns)} columns.\n"
-        result += f"File: {file_info.name} ({FileUtils.format_file_size(file_info.size)})\n"
-        result += f"Columns: {', '.join(df.columns)}\n\n"
-        result += "Summary statistics:\n"
-        result += str(df.describe())
-        return FileUtils.create_tool_response("analyze_excel_file", result=result, file_info=file_info)
+        _, payload = _apply_pandas_query(
+            df,
+            query=query if isinstance(query, str) and query.strip() else None,
+            preview_opts=None,
+            plot_opts=None,
+        )
+        header = (
+            f"Excel file loaded with {len(df)} rows and {len(df.columns)} columns.\n"
+            f"File: {file_info.name} ({FileUtils.format_file_size(file_info.size)})\n"
+        )
+        result_parts = [header]
+        if payload.get("table_markdown"):
+            result_parts.append("Preview:\n" + payload["table_markdown"])
+        if payload.get("describe_summary"):
+            result_parts.append("\n\nSummary statistics:\n" + str(payload["describe_summary"]))
+        result_text = "\n".join(result_parts)
+        return FileUtils.create_tool_response(
+            "analyze_excel_file",
+            result=result_text,
+            file_info=file_info,
+            extra=payload,
+        )
     except Exception as e:
         # Enhanced error reporting: print columns and head if possible
         try:
@@ -1038,7 +1246,7 @@ def analyze_image(file_reference: str, agent=None) -> str:
             "color_analysis": color_analysis,
             "thumbnail": thumbnail_base64,
         }
-        return FileUtils.create_tool_response("analyze_image", result=result)
+        return FileUtils.create_tool_response("analyze_image", result=json.dumps(result))
     except Exception as e:
         return FileUtils.create_tool_response("analyze_image", error=str(e))
 
@@ -1205,17 +1413,23 @@ def draw_on_image(image_base64: str, drawing_type: str, params: DrawOnImageParam
         }, indent=2)
 
 class GenerateSimpleImageParams(BaseModel):
+    image_type: str = Field(..., description="Type of image to generate: 'solid', 'gradient', 'checkerboard', 'noise'")
+    width: int = Field(500, description="Width of the generated image")
+    height: int = Field(500, description="Height of the generated image")
     color: Optional[str] = Field(None, description="Solid color for 'solid' type (e.g., 'red', 'blue') or RGB string (e.g., '255,0,0')")
     start_color: Optional[List[int]] = Field(None, description="Gradient start color [r, g, b]")
     end_color: Optional[List[int]] = Field(None, description="Gradient end color [r, g, b]")
-    direction: Optional[Literal["horizontal", "vertical"]] = Field(None, description="Gradient direction")
+    direction: Optional[Literal["horizontal", "vertical"]] = Field(None, description="Gradient direction ('horizontal' or 'vertical')")
     square_size: Optional[int] = Field(None, description="Square size for checkerboard")
     color1: Optional[str] = Field(None, description="First color for checkerboard")
     color2: Optional[str] = Field(None, description="Second color for checkerboard")
 
 @tool(args_schema=GenerateSimpleImageParams)
 def generate_simple_image(image_type: str, width: int = 500, height: int = 500, 
-                         params: Optional[Dict[str, Any]] = None) -> str:
+                         color: Optional[str] = None, start_color: Optional[List[int]] = None,
+                         end_color: Optional[List[int]] = None, direction: Optional[str] = None,
+                         square_size: Optional[int] = None, color1: Optional[str] = None,
+                         color2: Optional[str] = None) -> str:
     """
     Generate simple images like gradients, solid colors, checkerboard, or noise patterns.
 
@@ -1229,9 +1443,8 @@ def generate_simple_image(image_type: str, width: int = 500, height: int = 500,
         str: JSON string with the generated image as base64 or error message.
     """
     try:
-        params = params or {}
         if image_type == "solid":
-            color_str = params.get("color", "255,255,255")
+            color_str = color or "255,255,255"
             # Parse color string to RGB tuple
             if "," in color_str and color_str.replace(",", "").replace(" ", "").isdigit():
                 try:
@@ -1250,9 +1463,9 @@ def generate_simple_image(image_type: str, width: int = 500, height: int = 500,
                     color = (255, 255, 255)
             img = Image.new("RGB", (width, height), color)
         elif image_type == "gradient":
-            start_color = params.get("start_color", [255, 0, 0])
-            end_color = params.get("end_color", [0, 0, 255])
-            direction = params.get("direction", "horizontal")
+            start_color = start_color or [255, 0, 0]
+            end_color = end_color or [0, 0, 255]
+            direction = direction or "horizontal"
             img = Image.new("RGB", (width, height))
             draw = ImageDraw.Draw(img)
             if direction == "horizontal":
@@ -1271,9 +1484,9 @@ def generate_simple_image(image_type: str, width: int = 500, height: int = 500,
             noise_array = np.random.randint(0, 256, (height, width, 3), dtype=np.uint8)
             img = Image.fromarray(noise_array, "RGB")
         elif image_type == "checkerboard":
-            square_size = params.get("square_size", 50)
-            color1 = params.get("color1", "white")
-            color2 = params.get("color2", "black")
+            square_size = square_size or 50
+            color1 = color1 or "white"
+            color2 = color2 or "black"
             img = Image.new("RGB", (width, height))
             for y in range(0, height, square_size):
                 for x in range(0, width, square_size):