feat!: add chatbot demo ui

- Add MCP Chat Interface Usage section with natural language examples
- Enhance Architecture section with MCPClientWrapper and MCP components
- Add 5 new features: Chat Interface, Streaming Tool Calls, Tool Detection, JSON Repair, Dual Response
- Document MCP Chat Interface Technical Details with streaming assembly specs
- Add intelligent tool detection system with keyword-based scheduling detection
- Document dual response architecture (Nebius API + MCP fallback)
- Update Future Work with MCP-specific enhancements and performance optimization
- Add streaming tool call processing details (200+ delta handling, 60s timeout)
- Update usage examples with specific technical tasks
- Document JSON repair system and comprehensive error handling mechanisms

README.md

@@ -24,31 +24,26 @@ It takes a project description, breaks it down into actionable tasks through a [
 **Source Code on GitHub:**
 [https://github.com/blackopsrepl/yuga-planner](https://github.com/blackopsrepl/yuga-planner)
 
-### Gradio Web Demo Usage
+### MCP Chat Interface Usage
 
-1. Go to [the live demo](https://huggingface.co/spaces/blackopsrepl/yuga-planner) or [http://localhost:7860](http://localhost:7860)
-
-2. **Upload project files** or **use mock projects:**
-   - Upload one or more Markdown project file(s), then click "Load Data"
-   - OR select from pre-configured mock projects for quick testing
-   - Each file will be taken as a separate project
-   - The app will parse, decompose, and estimate tasks using LLM agents
-
-3. **Generate schedule:**
-   - Click "Solve" to generate an optimal schedule against a randomly generated team
-   - View results interactively with real-time solver progress
-   - Task order is preserved within each project
+1. **Navigate to the Chat tab** in the Gradio interface
+2. **Upload your calendar file (.ics)** to provide existing commitments (optional)
+3. **Type your scheduling request** using natural language:
+   ```
+   "Create a new EC2 instance on AWS"
+   "Create a Svelte UI that allows me to query a postgresql database"
+   "Develop a chatbot UI based on Gradio"
+   ```
+4. **Receive intelligent responses** that combine conversational AI with task scheduling capabilities
+5. **View formatted schedules** with rich table output and status indicators
 
 ### MCP Tool Usage
-
 1. **In any MCP-compatible chatbot or agent platform:**
    ```
    use yuga-planner mcp tool
    Task Description: [Your task description]
    ```
-
 2. **Attach your calendar file (.ics)** to provide existing commitments
-
 3. **Receive optimized schedule** that integrates your new task with existing calendar events
 
 ## Architecture
@@ -61,6 +56,13 @@ Yuga Planner follows a **service-oriented architecture** with clear separation o
 - **StateService:** Centralized state management for job tracking and schedule storage
 - **LoggingService:** Real-time log streaming for UI feedback and debugging
 - **MockProjectService:** Provides sample project data for testing and demos
+- **MCPClientWrapper:** Manages MCP server functionality and tool definitions
+
+### MCP Integration Components
+- **ToolCallAssembler:** Processes streaming tool call deltas from Nebius API into complete tool calls
+- **ToolCallProcessor:** Executes completed tool calls via MCP backend with JSON repair functionality
+- **Chat Interface:** Unified conversational AI + task scheduling with intelligent tool detection
+- **Streaming Handler:** Real-time response processing with progress indicators and error recovery
 
 ### System Components
 - **Gradio UI:** Modern web interface with real-time updates and interactive schedule visualization
@@ -86,17 +88,25 @@ Yuga Planner follows a **service-oriented architecture** with clear separation o
 | **Business Hours Enforcement** | Respects 9:00-18:00 working hours with lunch break exclusion | ✅ |
 | **Weekend Scheduling Prevention** | Hard constraint preventing weekend task assignments | ✅ |
 | **MCP Endpoint** | API endpoint for MCP tool integration with calendar support | ✅ |
+| **Chat Interface with MCP** | Unified conversational AI + task scheduling interface | ✅ |
+| **Streaming Tool Calls** | Real-time processing of tool calls from Nebius API | ✅ |
+| **Intelligent Tool Detection** | Keyword-based detection for scheduling requests | ✅ |
+| **JSON Repair & Recovery** | Robust handling of malformed streaming data | ✅ |
+| **Dual Response System** | Nebius API with MCP fallback for reliability | ✅ |
 
 ## 🎯 Two Usage Modes
-
 Yuga Planner operates as **two separate systems** serving different use cases:
 
-### 1. 🖥️ Gradio Web Demo
-**Purpose:** Interactive team scheduling for project management
-- **Access:** [Live demo](https://huggingface.co/spaces/blackopsrepl/yuga-planner) or local web interface
-- **Input:** Upload Markdown project files or use pre-configured mock projects
-- **Team:** Schedules against a **randomly generated team** with diverse skills and availability
-- **Use Case:** Project managers scheduling real teams for complex multi-project workloads
+### 1. 💬 MCP Chat Interface
+**Purpose:** Conversational AI with integrated task scheduling capabilities
+- **Access:** Chat tab in the Gradio interface
+- **Input:** Natural language requests + optional `.ics` calendar files
+- **Features:**
+  - Intelligent tool detection based on scheduling keywords
+  - Streaming responses with real-time tool call assembly
+  - Rich table formatting for schedule results
+  - Dual response system (Nebius API + MCP fallback)
+- **Use Case:** Interactive scheduling through natural conversation
 
 ### 2. 🤖 MCP Personal Tool
 **Purpose:** Individual task scheduling integrated with personal calendars
@@ -115,7 +125,27 @@ Tool Response: Optimized schedule created - EC2 setup task assigned to
 available time slots around your existing meetings
 ```
 
-## 🧩 MCP Tool Integration Details
+## 🧩 MCP Chat Interface Technical Details
+### Intelligent Tool Detection
+The chat interface automatically detects scheduling requests using keyword analysis:
+```python
+scheduling_keywords = [
+    'schedule', 'task', 'calendar', 'plan', 'organize',
+    'meeting', 'appointment', 'project', 'deadline',
+    'create', 'setup', 'implement', 'develop'
+]
+```
+
+### Streaming Tool Call Processing
+- **Delta Assembly:** Collects 200+ streaming deltas into complete tool calls
+- **JSON Repair:** Handles malformed JSON from streaming responses
+- **Progress Indicators:** Real-time feedback during tool processing
+- **Timeout Protection:** 60-second timeout for MCP operations
+
+### Dual Response System
+- **Primary:** Nebius API with tool calling capabilities
+- **Fallback:** Direct MCP backend invocation when tool assembly fails
+- **Error Recovery:** Comprehensive error handling and graceful degradation
 
 **Features:**
 - Accepts calendar files and user task descriptions via chat interface
@@ -125,105 +155,84 @@ available time slots around your existing meetings
 - Designed for seamless chatbot and agent workflow integration
 
 **Current Limitations:**
-- **Cross-system integration:** Gradio web demo and MCP personal tool operate as separate systems
 - **Multi-timezone support:** Currently operates in a single timezone context with UTC conversion for consistency. Calendar events from different timezones are normalized to the same scheduling context.
 
 See the [CHANGELOG.md](CHANGELOG.md) for details on recent MCP-related changes.
 
-### Recent Improvements ✅
-
-- **Service Architecture Refactoring:** Complete service-oriented architecture with proper encapsulation and clean boundaries
-- **State Management:** Centralized state handling through dedicated StateService
-- **Handler Compliance:** Clean separation between UI handlers and business logic services
-- **Method Encapsulation:** Fixed all private method violations for better code maintainability
-
 ### Work in Progress
-
 - **🔧 Gradio UI overhaul:** Enhanced user experience and visual improvements
 - **🔍 Migration to Pydantic models:** Type-safe data validation and serialization
-- **📚 Migrate from violation_analyzer to Timefold dedicated libraries**
 - **⚡ Enhanced timezone support:** Multi-timezone calendar integration for international scheduling
 
 ### Future Work
-
 #### System Integration Roadmap
-Currently, the **Gradio web demo** and **MCP personal tool** operate as separate systems. As the project evolves, these will become **more integrated**, enabling:
 - **Unified scheduling engine** that can handle both team management and personal productivity in one interface
 - **Hybrid workflows** where personal tasks can be coordinated with team projects
 - **Cross-system data sharing** between web demo projects and personal MCP calendars
 - **Seamless switching** between team management and individual task planning modes
 
 #### Core Feature Enhancements
+- **Multi-Tool Support:** Extend chat interface to support additional MCP tools beyond scheduling
+- **Calendar Integration:** Direct calendar service integration (Google, Outlook)
+- **Performance Optimization:** Enhanced streaming assembly for large tool calls
 - **RAG:** validation of task decomposition and estimation against industry relevant literature
-- **More granular task dependency:** representation of tasks in a tree instead of a list to allow overlap within projects, where feasible/convenient
+- **More granular task dependency:** representation of tasks in a DAG instead of a list to allow overlap within projects, where feasible/convenient
 - **Input from GitHub issues:** instead of processing markdown directly, it creates a list by parsing issue
-- **Chat interface:** detection of user intent, with on-the-fly CRUD operations on team, tasks and schedules
 - **Reinforcement learning:** training the agent to improve task decomposition and estimation from GitHub history (e.g. diffs in timestamps, issue comments etc.)
 
 ## Prerequisites (Local/GitHub)
-
 - Python 3.10
 - Java 17+
 - Docker (optional, for containerized deployment)
 - Nebius API credentials (for LLM-powered features)
 
 ### Installation
-
 1. **Clone the repository:**
    ```bash
    git clone https://github.com/blackopsrepl/yuga-planner.git
    cd yuga-planner
    ```
-
 2. **Create a virtual environment:**
    ```bash
    make venv
    ```
-
 3. **Install dependencies:**
    ```bash
    make install
    ```
-
 4. **Set up environment variables / secrets:**
    ```bash
    make setup-secrets
    # Then edit tests/secrets/cred.py to add your API credentials
    ```
-
 5. **Run the app:**
    ```bash
    make run
    ```
 
 #### Docker (Local/GitHub)
-
 1. **Build the image:**
    ```bash
    docker build -t yuga-planner .
    ```
-
 2. **Run the container:**
    ```bash
-   docker run -p 7860:786
+   docker run -p 7860:7860 yuga-planner
    ```
 
 ---
 
 ## Python Dependencies
-
 See `requirements.txt` for full list.
 
 ---
 
 ## License
-
 This project is licensed under the Apache 2.0 License. See [LICENSE.txt](LICENSE.txt) for details.
 
 ---
 
 ## Acknowledgements
-
 - [Hugging Face](https://huggingface.co/)
 - [Gradio](https://gradio.app/)
 - [Nebius LLM](https://nebius.ai/)

src/app.py

@@ -7,23 +7,10 @@ from utils.logging_config import setup_logging, get_logger
 setup_logging()
 logger = get_logger(__name__)
 
-from utils.load_secrets import load_secrets
-
-if not os.getenv("NEBIUS_API_KEY") or not os.getenv("NEBIUS_MODEL"):
-    load_secrets("tests/secrets/creds.py")
-
-
-# from handlers.web_backend import (
-#     load_data,
-#     show_solved,
-#     start_timer,
-#     auto_poll,
-#     show_mock_project_content,
-# )
-
 from handlers.mcp_backend import process_message_and_attached_file
+from ui.pages.chat import draw_chat_page
+from ui.pages.mcp_info import draw_info_page
 
-from services import MockProjectService
 
 # Store last chat message and file in global variables (for demo purposes)
 last_message_body = None
@@ -55,14 +42,11 @@ def app(debug: bool = False):
 
             **Yuga Planner** is a neuro-symbolic system that combines AI agents with constraint optimization
             for intelligent scheduling.
-
-            ## 🔌 **Using as MCP Tool**
-
-            You can use Yuga Planner as an MCP server to integrate scheduling into your AI workflows.
             """
         )
 
-        _draw_info_page(debug)
+        draw_chat_page(debug)
+        draw_info_page(debug)
 
         # Register the MCP tool as an API endpoint
         gr.api(process_message_and_attached_file)
@@ -70,126 +54,6 @@ def app(debug: bool = False):
     return demo
 
 
-def _draw_info_page(debug: bool = False):
-    with gr.Tab("📋 Information"):
-
-        def get_server_url():
-            try:
-                return gr.get_state().server_url + "/gradio_api/mcp/sse"
-            except:
-                return "https://blackopsrepl-yuga-planner.hf.space/gradio_api/mcp/sse"
-
-        gr.Textbox(
-            value=get_server_url(),
-            label="🌐 MCP Server Endpoint",
-            interactive=False,
-            max_lines=1,
-        )
-
-        with gr.Accordion("📝 MCP Setup Instructions", open=True):
-            gr.Markdown(
-                """
-                ### 1. **Cursor Setup Instructions (should work from any MCP client!)**
-
-                **For Cursor AI Editor:**
-                1. Create or edit your MCP configuration file: `~/.cursor/mcp.json`
-                2. Add the yuga-planner server configuration:
-                ```json
-                {
-                  "mcpServers": {
-                    "yuga-planner": {
-                      "url": -> "Insert the above endpoint URL here"
-                    }
-                  }
-                }
-                ```
-                3. If you already have other MCP servers, add `yuga-planner` to the existing `mcpServers` object
-                4. Restart Cursor to load the new configuration
-                5. The tool will be available in your chat
-
-                ### 2. **Usage Example**
-                """
-            )
-
-            gr.Textbox(
-                value="""use yuga-planner mcp tool
-Task Description: Create a new EC2 instance on AWS
-
-[Attach your calendar.ics file to provide existing commitments]
-
-Tool Response: Optimized schedule created - EC2 setup task assigned to
-available time slots around your existing meetings
-[Returns JSON response with schedule data]
-
-User: show all fields as a table, ordered by start date
-
-[Displays formatted schedule table with all tasks and calendar events]""",
-                label="💬 Cursor Chat Usage Example",
-                interactive=False,
-                lines=10,
-            )
-
-            gr.Markdown(
-                """
-                ### 3. **What it does**
-
-                **Personal Task Scheduling with Calendar Integration:**
-
-                1. 📅 **Parses your calendar** (.ics file) for existing commitments
-                2. 🤖 **AI breaks down your task** into actionable subtasks using LLamaIndex + Nebius AI
-                3. ⚡ **Constraint-based optimization** finds optimal time slots around your existing schedule
-                4. 📋 **Returns complete solved schedule** integrated with your personal calendar events
-                5. 🕘 **Respects business hours** (9:00-18:00) and excludes weekends automatically
-                6. 📊 **JSON response format** - Ask to "show all fields as a table, ordered by start date" for readable formatting
-
-                **Designed for**: Personal productivity and task planning around existing appointments in Cursor.
-                """
-            )
-
-        if debug:
-            with gr.Tab("🐛 Debug Info"):
-                gr.Markdown(
-                    """
-                    # 🐛 Debug Information
-
-                    **Debug Mode Enabled** - Additional system information and controls available.
-                    """
-                )
-
-                with gr.Accordion("🔧 **Environment Details**", open=True):
-                    import os
-
-                    env_info = f"""
-                    **🐍 Python Environment**
-                    - Debug Mode: {debug}
-                    - YUGA_DEBUG: {os.getenv('YUGA_DEBUG', 'Not Set')}
-                    - Nebius API Key: {'✅ Set' if os.getenv('NEBIUS_API_KEY') else '❌ Not Set'}
-                    - Nebius Model: {os.getenv('NEBIUS_MODEL', 'Not Set')}
-
-                    **🌐 Server Information**
-                    - MCP Endpoint: {get_server_url()}
-                    - Current Working Directory: {os.getcwd()}
-                    """
-                    gr.Markdown(env_info)
-
-                with gr.Accordion("📊 **System Status**", open=False):
-                    gr.Markdown(
-                        """
-                        **🔄 Service Status**
-                        - DataService: ✅ Active
-                        - ScheduleService: ✅ Active
-                        - StateService: ✅ Active
-                        - LoggingService: ✅ Active
-                        - MockProjectService: ✅ Active
-
-                        **🔌 Integration Status**
-                        - MCP Server: ✅ Enabled
-                        - Gradio API: ✅ Active
-                        - Real-time Logs: ✅ Streaming
-                        """
-                    )
-
-
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(
         description="Yuga Planner - Team Scheduling Application"

src/domain.py

@@ -1,6 +1,12 @@
 import os, warnings
 from dataclasses import dataclass
 
+# Load secrets if environment variables are not set
+from utils.load_secrets import load_secrets
+
+if not os.getenv("NEBIUS_API_KEY") or not os.getenv("NEBIUS_MODEL"):
+    load_secrets("tests/secrets/creds.py")
+
 # =========================
 #        MOCK PROJECTS
 # =========================

src/handlers/__init__.py

@@ -16,6 +16,12 @@ from .mcp_backend import (
     process_message_and_attached_file,
 )
 
+from .tool_call_handler import (
+    ToolCallAssembler,
+    ToolCallProcessor,
+    create_tool_call_handler,
+)
+
 __all__ = [
     "load_data",
     "show_solved",
@@ -23,4 +29,7 @@ __all__ = [
     "auto_poll",
     "show_mock_project_content",
     "process_message_and_attached_file",
+    "ToolCallAssembler",
+    "ToolCallProcessor",
+    "create_tool_call_handler",
 ]

src/handlers/tool_call_handler.py

@@ -0,0 +1,454 @@
+import json
+import re
+import asyncio
+from typing import Dict, List, Any, Optional
+from utils.logging_config import setup_logging, get_logger
+
+# Initialize logging
+setup_logging()
+logger = get_logger(__name__)
+
+
+class ToolCallAssembler:
+    """Handles streaming tool call assembly from API responses"""
+
+    def __init__(self):
+        self.tool_calls: Dict[int, Dict[str, Any]] = {}
+        self.reset()
+
+    def reset(self):
+        """Reset the assembler for a new conversation"""
+        self.tool_calls = {}
+
+    def process_delta(self, delta: Dict[str, Any]) -> None:
+        """Process a single delta from streaming response"""
+        if "tool_calls" not in delta:
+            return
+
+        for tool_call_delta in delta["tool_calls"]:
+            index = tool_call_delta.get("index", 0)
+
+            # Initialize tool call if not exists
+            if index not in self.tool_calls:
+                self.tool_calls[index] = {
+                    "id": "",
+                    "type": "function",
+                    "function": {"name": "", "arguments": ""},
+                }
+
+            # Update tool call components
+            if "id" in tool_call_delta:
+                self.tool_calls[index]["id"] = tool_call_delta["id"]
+            if "type" in tool_call_delta:
+                self.tool_calls[index]["type"] = tool_call_delta["type"]
+            if "function" in tool_call_delta:
+                if "name" in tool_call_delta["function"]:
+                    self.tool_calls[index]["function"]["name"] = tool_call_delta[
+                        "function"
+                    ]["name"]
+                if "arguments" in tool_call_delta["function"]:
+                    # Append arguments (they come in chunks)
+                    self.tool_calls[index]["function"]["arguments"] += tool_call_delta[
+                        "function"
+                    ]["arguments"]
+
+    def get_completed_tool_calls(self) -> List[Dict[str, Any]]:
+        """Get list of completed tool calls"""
+        completed = []
+        for tool_call in self.tool_calls.values():
+            # Check if tool call is complete (has name and valid JSON arguments)
+            if tool_call["function"]["name"] and tool_call["function"]["arguments"]:
+                try:
+                    # Validate JSON arguments
+                    json.loads(tool_call["function"]["arguments"])
+                    completed.append(tool_call)
+                except json.JSONDecodeError as e:
+                    logger.warning(
+                        f"Tool call {tool_call['id']} has invalid JSON arguments: {e}"
+                    )
+                    logger.debug(f"Arguments: {tool_call['function']['arguments']}")
+
+                    # Enhanced debugging for character 805 issue
+                    args = tool_call["function"]["arguments"]
+                    error_pos = getattr(e, "pos", 804)  # Get error position
+
+                    if error_pos > 0:
+                        # Show context around the error
+                        start = max(0, error_pos - 50)
+                        end = min(len(args), error_pos + 50)
+                        context = args[start:end]
+
+                        logger.error(f"JSON Error Context (around char {error_pos}):")
+                        logger.error(
+                            f"  Before error: '{args[max(0, error_pos-20):error_pos]}'"
+                        )
+                        logger.error(
+                            f"  At error: '{args[error_pos:error_pos+1] if error_pos < len(args) else 'END'}'"
+                        )
+                        logger.error(
+                            f"  After error: '{args[error_pos+1:error_pos+21] if error_pos < len(args) else ''}'"
+                        )
+                        logger.error(f"  Full context: '{context}'")
+
+                        # Check if it's the calendar data causing issues
+                        if "calendar_file_content" in args:
+                            # Find where calendar data starts and ends
+                            cal_start = args.find('"calendar_file_content":"')
+                            if cal_start != -1:
+                                cal_data_start = cal_start + len(
+                                    '"calendar_file_content":"'
+                                )
+                                # Look for the closing quote
+                                cal_end = args.find('"', cal_data_start + 1)
+                                if cal_end != -1:
+                                    logger.error(
+                                        f"Calendar data length: {cal_end - cal_data_start}"
+                                    )
+                                    logger.error(
+                                        f"Calendar data starts at: {cal_data_start}"
+                                    )
+                                    logger.error(f"Calendar data ends at: {cal_end}")
+                                    logger.error(
+                                        f"Error position relative to cal data: {error_pos - cal_data_start}"
+                                    )
+                                else:
+                                    logger.error("Calendar data has no closing quote!")
+                            else:
+                                logger.error(
+                                    "No calendar_file_content found in arguments"
+                                )
+
+                    # Try to repair the JSON by attempting common fixes
+                    try:
+                        repaired_args = self._attempt_json_repair(args)
+                        if repaired_args:
+                            json.loads(repaired_args)  # Test if repair worked
+                            logger.info(
+                                f"Successfully repaired JSON for tool call {tool_call['id']}"
+                            )
+                            # Update the tool call with repaired arguments
+                            tool_call["function"]["arguments"] = repaired_args
+                            completed.append(tool_call)
+                            continue
+                    except:
+                        logger.debug("JSON repair attempt failed")
+
+        return completed
+
+    def _attempt_json_repair(self, broken_json: str) -> str:
+        """Attempt to repair common JSON issues"""
+        try:
+            # Common issue: Missing closing brace
+            if not broken_json.strip().endswith("}"):
+                return broken_json.strip() + "}"
+
+            # Common issue: Malformed calendar data causing JSON breaks
+            # The error is likely around character 795 in the base64 data
+            if '"calendar_file_content":"' in broken_json:
+                # Try to find and fix the calendar field
+                start_pattern = '"calendar_file_content":"'
+                start_idx = broken_json.find(start_pattern)
+
+                if start_idx != -1:
+                    content_start = start_idx + len(start_pattern)
+
+                    # Find the actual end of the JSON by looking for the pattern
+                    # that should follow calendar content: "} or ",
+                    remaining = broken_json[content_start:]
+
+                    # Look for what appears to be a duplicate task_description field
+                    # This indicates where the JSON got corrupted
+                    duplicate_pattern = r'"[\s\S]*?\{\s*"task_description"'
+                    match = re.search(duplicate_pattern, remaining)
+
+                    if match:
+                        # The base64 data should end before this match
+                        clean_end_pos = content_start + match.start()
+
+                        # Extract the clean calendar data (everything before the corrupted part)
+                        clean_calendar_data = (
+                            broken_json[content_start:clean_end_pos]
+                            .rstrip('"')
+                            .rstrip()
+                        )
+
+                        # Extract the task description from the duplicate section
+                        dup_start = content_start + match.start()
+                        dup_content = broken_json[dup_start:]
+
+                        # Find the actual JSON structure in the duplicate content
+                        dup_json_start = dup_content.find('{"task_description"')
+                        if dup_json_start != -1:
+                            clean_rest = dup_content[dup_json_start:]
+
+                            # Remove any trailing garbage that might cause JSON issues
+                            if not clean_rest.endswith("}"):
+                                # Try to find the proper ending
+                                brace_count = 0
+                                proper_end = -1
+                                for i, char in enumerate(clean_rest):
+                                    if char == "{":
+                                        brace_count += 1
+                                    elif char == "}":
+                                        brace_count -= 1
+                                        if brace_count == 0:
+                                            proper_end = i + 1
+                                            break
+
+                                if proper_end != -1:
+                                    clean_rest = clean_rest[:proper_end]
+                                else:
+                                    clean_rest = clean_rest.rstrip() + "}"
+
+                            # Parse the clean rest to extract just the fields we need
+                            try:
+                                rest_obj = json.loads(clean_rest)
+                                task_desc = rest_obj.get("task_description", "")
+
+                                # Reconstruct the proper JSON
+                                repaired_obj = {
+                                    "task_description": task_desc,
+                                    "calendar_file_content": clean_calendar_data,
+                                }
+
+                                repaired = json.dumps(repaired_obj)
+                                logger.debug(
+                                    f"Successfully reconstructed JSON with task: {task_desc[:50]}..."
+                                )
+                                logger.debug(
+                                    f"Calendar data length: {len(clean_calendar_data)}"
+                                )
+                                return repaired
+
+                            except json.JSONDecodeError as e:
+                                logger.debug(
+                                    f"Failed to parse extracted duplicate section: {e}"
+                                )
+                                # Fallback to simple reconstruction
+                                repaired = f'{{"task_description":"","calendar_file_content":"{clean_calendar_data}"}}'
+                                logger.debug(
+                                    f"Fallback repair with calendar data length: {len(clean_calendar_data)}"
+                                )
+                                return repaired
+
+                    # Alternative: Look for more traditional closing patterns
+                    # Find where the base64 data properly ends with quote+comma or quote+brace
+                    for i, char in enumerate(remaining):
+                        if char == '"':
+                            # Check what follows the quote
+                            next_chars = (
+                                remaining[i : i + 3]
+                                if i + 3 <= len(remaining)
+                                else remaining[i:]
+                            )
+                            if next_chars.startswith('",') or next_chars.startswith(
+                                '"}'
+                            ):
+                                # This looks like a proper end
+                                calendar_data = remaining[:i]
+                                rest = remaining[i:]
+                                repaired = (
+                                    broken_json[:content_start] + calendar_data + rest
+                                )
+                                logger.debug(
+                                    f"Pattern-based repair: calendar data length {len(calendar_data)}"
+                                )
+                                return repaired
+
+            # If calendar repair didn't work, try other common fixes
+            # Remove any stray characters that might have been inserted
+            cleaned = re.sub(
+                r"[^\x20-\x7E]", "", broken_json
+            )  # Remove non-printable chars
+            if cleaned != broken_json:
+                logger.debug("Attempted to remove non-printable characters")
+                return cleaned
+
+            # Last resort: Try to extract valid JSON from the string
+            # Look for the first { and try to find matching }
+            first_brace = broken_json.find("{")
+            if first_brace != -1:
+                brace_count = 0
+                for i in range(first_brace, len(broken_json)):
+                    if broken_json[i] == "{":
+                        brace_count += 1
+                    elif broken_json[i] == "}":
+                        brace_count -= 1
+                        if brace_count == 0:
+                            candidate = broken_json[first_brace : i + 1]
+                            try:
+                                json.loads(candidate)
+                                logger.debug(
+                                    f"Extracted valid JSON segment of length {len(candidate)}"
+                                )
+                                return candidate
+                            except:
+                                continue
+
+            return None
+        except Exception as e:
+            logger.debug(f"JSON repair attempt failed: {e}")
+            return None
+
+    def debug_info(self) -> Dict[str, Any]:
+        """Get debug information about current tool calls"""
+        info = {
+            "total_tool_calls": len(self.tool_calls),
+            "completed_tool_calls": len(self.get_completed_tool_calls()),
+            "tool_calls_detail": {},
+        }
+
+        for index, tool_call in self.tool_calls.items():
+            info["tool_calls_detail"][index] = {
+                "id": tool_call["id"],
+                "function_name": tool_call["function"]["name"],
+                "arguments_length": len(tool_call["function"]["arguments"]),
+                "arguments_preview": tool_call["function"]["arguments"][:100] + "..."
+                if len(tool_call["function"]["arguments"]) > 100
+                else tool_call["function"]["arguments"],
+                "is_json_valid": self._is_valid_json(
+                    tool_call["function"]["arguments"]
+                ),
+            }
+
+        return info
+
+    def _is_valid_json(self, json_str: str) -> bool:
+        """Check if string is valid JSON"""
+        try:
+            json.loads(json_str)
+            return True
+        except:
+            return False
+
+
+class ToolCallProcessor:
+    """Processes completed tool calls"""
+
+    def __init__(self, mcp_client):
+        self.mcp_client = mcp_client
+        self.loop = None
+        try:
+            self.loop = asyncio.get_event_loop()
+        except RuntimeError:
+            self.loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self.loop)
+
+    def process_tool_calls(self, tool_calls: List[Dict[str, Any]], message: str) -> str:
+        """Process a list of tool calls and return response text"""
+        if not tool_calls:
+            return ""
+
+        response_parts = []
+
+        for tool_call in tool_calls:
+            logger.info(f"Processing tool call: {tool_call}")
+
+            try:
+                # Extract function details
+                function_name = tool_call.get("function", {}).get("name", "")
+                function_args_str = tool_call.get("function", {}).get("arguments", "{}")
+
+                if function_name == "schedule_tasks_with_calendar":
+                    result = self._process_scheduling_tool(function_args_str, message)
+                    response_parts.append(result)
+                else:
+                    logger.debug(f"Ignoring non-scheduling tool: {function_name}")
+
+            except Exception as e:
+                logger.error(f"Error processing tool call: {e}")
+                response_parts.append(f"\n\n❌ **Error processing tool call:** {str(e)}")
+
+        return "".join(response_parts)
+
+    def _process_scheduling_tool(self, function_args_str: str, message: str) -> str:
+        """Process scheduling tool call"""
+        try:
+            # Parse arguments
+            args = json.loads(function_args_str)
+            task_description = args.get("task_description", "")
+            calendar_content = args.get("calendar_file_content", "none")
+
+            # Extract calendar data from message if available (override args)
+            calendar_match = re.search(r"\[CALENDAR_DATA:([^\]]+)\]", message)
+            if calendar_match:
+                calendar_content = calendar_match.group(1)
+                logger.debug("Found calendar data in message, overriding args")
+
+            logger.info(f"Calling MCP scheduling tool with task: {task_description}")
+
+            # Call the scheduling tool
+            result = self.loop.run_until_complete(
+                self.mcp_client.call_scheduling_tool(task_description, calendar_content)
+            )
+
+            logger.info(
+                f"MCP tool completed with status: {result.get('status', 'unknown')}"
+            )
+
+            return self._format_scheduling_result(result, task_description)
+
+        except json.JSONDecodeError as e:
+            logger.error(f"JSON decode error in tool arguments: {e}")
+            logger.debug(f"Raw arguments: {function_args_str}")
+            return f"\n\n❌ **Error parsing tool arguments:** {str(e)}\n\nRaw arguments preview: {function_args_str[:200]}..."
+        except Exception as e:
+            logger.error(f"Tool execution error: {e}")
+            return f"\n\n❌ **Error processing scheduling request:** {str(e)}"
+
+    def _format_scheduling_result(
+        self, result: Dict[str, Any], task_description: str
+    ) -> str:
+        """Format the scheduling result for display"""
+        if result.get("status") == "success":
+            schedule = result.get("schedule", [])
+            calendar_entries = result.get("calendar_entries", [])
+
+            return f"""
+
+📅 **Schedule Generated Successfully!**
+
+**Task:** {task_description}
+**Calendar Events Processed:** {len(calendar_entries)}
+**Total Scheduled Items:** {len(schedule)}
+
+**Summary:**
+- ✅ Existing calendar events preserved at original times
+- 🆕 New tasks optimized around existing commitments
+- ⏰ All scheduling respects business hours (9:00-18:00)
+- 📋 Complete schedule integration
+
+To see the detailed schedule, ask me to "show the schedule as a table" or "format the schedule results".
+"""
+        elif result.get("status") == "timeout":
+            return f"""
+
+⏰ **Scheduling Analysis In Progress**
+
+The schedule optimizer is still working on your complex task: "{task_description}"
+
+This indicates a sophisticated scheduling challenge with multiple constraints. The system is finding the optimal arrangement for your tasks around existing calendar commitments.
+
+You can check back in a few moments or try with a simpler task description.
+"""
+        else:
+            error_msg = result.get("error", "Unknown error")
+            return f"""
+
+❌ **Scheduling Error**
+
+I encountered an issue while processing your scheduling request: {error_msg}
+
+Please try:
+- Simplifying your task description
+- Checking if you have calendar conflicts
+- Ensuring your .ics file is valid (if uploaded)
+"""
+
+
+def create_tool_call_handler(mcp_client):
+    """Factory function to create a complete tool call handler"""
+    assembler = ToolCallAssembler()
+    processor = ToolCallProcessor(mcp_client)
+
+    return assembler, processor

src/services/__init__.py

@@ -9,6 +9,7 @@ from .schedule import ScheduleService
 from .data import DataService
 from .mock_projects import MockProjectService
 from .state import StateService
+from .mcp_client import MCPClientService
 
 __all__ = [
     "LoggingService",
@@ -16,4 +17,5 @@ __all__ = [
     "DataService",
     "MockProjectService",
     "StateService",
+    "MCPClientService",
 ]

src/services/mcp_client.py

@@ -0,0 +1,80 @@
+"""
+MCP Client Service for Yuga Planner
+
+This service handles Model Context Protocol client operations for scheduling tools.
+Provides a clean interface for integrating MCP scheduling functionality.
+"""
+
+import base64
+from typing import Dict, Any
+
+from utils.logging_config import setup_logging, get_logger
+from handlers.mcp_backend import process_message_and_attached_file
+
+# Initialize logging
+setup_logging()
+logger = get_logger(__name__)
+
+
+class MCPClientService:
+    """Service for MCP client operations and scheduling tool integration"""
+
+    def __init__(self):
+        self.tools = [
+            {
+                "type": "function",
+                "function": {
+                    "name": "schedule_tasks_with_calendar",
+                    "description": "Create an optimized schedule by analyzing calendar events and breaking down tasks. Upload a calendar .ics file and describe the task you want to schedule.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "task_description": {
+                                "type": "string",
+                                "description": "Description of the task or project to schedule (e.g., 'Create a new EC2 instance on AWS')",
+                            },
+                            "calendar_file_content": {
+                                "type": "string",
+                                "description": "Base64 encoded content of the .ics calendar file, or 'none' if no calendar provided",
+                            },
+                        },
+                        "required": ["task_description", "calendar_file_content"],
+                    },
+                },
+            }
+        ]
+
+    async def call_scheduling_tool(
+        self, task_description: str, calendar_file_content: str
+    ) -> Dict[str, Any]:
+        """
+        Call the scheduling backend tool.
+
+        Args:
+            task_description: Description of the task to schedule
+            calendar_file_content: Base64 encoded calendar content or 'none'
+
+        Returns:
+            Dict containing the scheduling result
+        """
+        try:
+            if calendar_file_content.lower() == "none":
+                file_content = b""
+            else:
+                file_content = base64.b64decode(calendar_file_content)
+
+            logger.debug(f"Calling MCP backend with task: {task_description}")
+            result = await process_message_and_attached_file(
+                file_content=file_content,
+                message_body=task_description,
+                file_name="calendar.ics",
+            )
+
+            logger.debug(
+                f"MCP backend returned status: {result.get('status', 'unknown')}"
+            )
+            return result
+
+        except Exception as e:
+            logger.error(f"Error calling scheduling tool: {e}")
+            return {"error": str(e), "status": "failed"}

src/ui/pages/chat.py

@@ -0,0 +1,705 @@
+import os, json, re
+import gradio as gr
+import asyncio
+from typing import List, Dict, Any, Union, Generator
+from contextlib import AsyncExitStack
+from datetime import datetime, date
+
+import requests
+
+from handlers.mcp_backend import process_message_and_attached_file
+from handlers.tool_call_handler import create_tool_call_handler
+from services.mcp_client import MCPClientService
+
+from utils.load_secrets import load_secrets
+
+if not os.getenv("NEBIUS_API_KEY") or not os.getenv("NEBIUS_MODEL"):
+    load_secrets("tests/secrets/creds.py")
+
+nebius_api_key = os.getenv("NEBIUS_API_KEY")
+nebius_model = os.getenv("NEBIUS_MODEL")
+
+from utils.logging_config import (
+    setup_logging,
+    get_logger,
+    start_session_logging,
+    get_session_logs,
+)
+
+# Initialize logging
+setup_logging()
+logger = get_logger(__name__)
+
+# Global MCP client for the chat page
+_mcp_client = None
+_tool_assembler = None
+_tool_processor = None
+
+# Get or create event loop for MCP operations
+try:
+    loop = asyncio.get_event_loop()
+except RuntimeError:
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+
+class DateTimeEncoder(json.JSONEncoder):
+    """Custom JSON encoder that handles datetime objects and other non-serializable types"""
+
+    def default(self, obj):
+        if isinstance(obj, (datetime, date)):
+            return obj.isoformat()
+        elif hasattr(obj, "__dict__"):
+            return str(obj)
+        elif hasattr(obj, "to_dict"):
+            return obj.to_dict()
+        else:
+            return str(obj)
+
+
+def safe_json_dumps(obj, **kwargs):
+    """Safely serialize objects to JSON, handling datetime and other non-serializable types"""
+    try:
+        return json.dumps(obj, cls=DateTimeEncoder, **kwargs)
+    except Exception as e:
+        logger.warning(
+            f"JSON serialization failed: {e}, falling back to string representation"
+        )
+        return json.dumps(
+            {"error": f"Serialization failed: {str(e)}", "raw_data": str(obj)[:1000]},
+            **kwargs,
+        )
+
+
+def draw_chat_page(debug: bool = False):
+    logger.info(f"NEBIUS_MODEL: {nebius_model}")
+    logger.info(f"NEBIUS_API_KEY: {'Set' if nebius_api_key else 'Not Set'}")
+
+    if not nebius_model or not nebius_api_key:
+        logger.error(
+            "NEBIUS_MODEL or NEBIUS_API_KEY not found in environment variables"
+        )
+
+    with gr.Tab("💬 Chat"):
+        gr.Markdown(
+            """
+            # 💬 Chat with Yuga Planner
+
+            This chatbot can help you with general questions and also schedule tasks around your calendar.
+            To use scheduling features, just describe your task and optionally upload a calendar .ics file.
+            """
+        )
+
+        if not nebius_model or not nebius_api_key:
+            gr.Markdown(
+                """
+                ⚠️ **Chat unavailable**: NEBIUS_MODEL or NEBIUS_API_KEY environment variables are not set.
+
+                Please configure your Nebius credentials to use the chat feature.
+                """
+            )
+            return
+
+        # Initialize MCP client and tool handlers as globals for this page
+        global _mcp_client, _tool_assembler, _tool_processor
+        _mcp_client = MCPClientService()
+        _tool_assembler, _tool_processor = create_tool_call_handler(_mcp_client)
+
+        # Create chat interface components
+        chatbot, msg, clear, calendar_file = create_chat_interface()
+
+        # Create parameter controls
+        (
+            system_message,
+            max_tokens_slider,
+            temperature_slider,
+            top_p_slider,
+        ) = create_chatbot_parameters()
+
+        msg.submit(
+            user_message, [msg, chatbot, calendar_file], [msg, chatbot], queue=False
+        ).then(
+            bot_response,
+            [
+                chatbot,
+                system_message,
+                max_tokens_slider,
+                temperature_slider,
+                top_p_slider,
+            ],
+            chatbot,
+            show_progress=True,
+        )
+
+        clear.click(lambda: [], None, chatbot, queue=False)
+
+
+def create_chat_interface() -> tuple[gr.Chatbot, gr.Textbox, gr.Button, gr.File]:
+    """Create and return the chat interface components"""
+    chatbot = gr.Chatbot(type="messages")
+    msg = gr.Textbox(
+        label="Your message",
+        placeholder="Type your message here... For scheduling, describe your task and optionally upload a calendar file.",
+    )
+    calendar_file = gr.File(
+        label="📅 Calendar File (.ics)", file_types=[".ics"], visible=True
+    )
+    clear = gr.Button("Clear")
+    return chatbot, msg, clear, calendar_file
+
+
+def create_chatbot_parameters() -> tuple[gr.Textbox, gr.Slider, gr.Slider, gr.Slider]:
+    """Create and return the chatbot parameter controls"""
+    with gr.Accordion("Chatbot Parameters", open=False):
+        system_message = gr.Textbox(
+            value="You are a friendly and helpful AI assistant that specializes in task scheduling and productivity. You can help users plan and organize their work around existing calendar commitments. When users ask about scheduling tasks or mention calendar-related activities, you should use the schedule_tasks_with_calendar tool to create optimized schedules. If you see [Calendar file uploaded:] in a message, the user has provided calendar data that should be used for scheduling. Always use the scheduling tool when users mention tasks, projects, scheduling, planning, or similar requests.",
+            label="System message",
+        )
+        max_tokens_slider = gr.Slider(
+            minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"
+        )
+        temperature_slider = gr.Slider(
+            minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"
+        )
+        top_p_slider = gr.Slider(
+            minimum=0.1,
+            maximum=1.0,
+            value=0.95,
+            step=0.05,
+            label="Top-p (nucleus sampling)",
+        )
+    return system_message, max_tokens_slider, temperature_slider, top_p_slider
+
+
+def user_message(message, history, calendar_file_obj):
+    # Handle calendar file upload
+    enhanced_message = message
+    if calendar_file_obj is not None:
+        # Read and encode the calendar file
+        try:
+            import base64
+
+            with open(calendar_file_obj, "rb") as f:
+                file_content = f.read()
+
+            encoded_content = base64.b64encode(file_content).decode("utf-8")
+            enhanced_message += (
+                f"\n\n[Calendar file uploaded: {calendar_file_obj.name}]"
+            )
+            enhanced_message += f"\n[CALENDAR_DATA:{encoded_content}]"
+        except Exception as e:
+            logger.error(f"Error reading calendar file: {e}")
+            enhanced_message += f"\n\n[Calendar file upload failed: {str(e)}]"
+
+    return "", history + [{"role": "user", "content": enhanced_message}]
+
+
+def bot_response(history, system_message, max_tokens, temperature, top_p):
+    if not history:
+        return history
+
+    # Convert messages format to tuples for the respond function
+    history_tuples = []
+    for msg in history[:-1]:  # All but the last message
+        if msg["role"] == "user":
+            history_tuples.append([msg["content"], ""])
+        elif msg["role"] == "assistant":
+            if history_tuples:
+                history_tuples[-1][1] = msg["content"]
+            else:
+                history_tuples.append(["", msg["content"]])
+
+    # Get the last user message
+    user_msg = history[-1]["content"]
+
+    logger.info(f"Bot response called with user message: {user_msg[:100]}...")
+
+    try:
+        # Get the response generator
+        response_gen = respond(
+            user_msg,
+            history_tuples,
+            system_message,
+            max_tokens,
+            temperature,
+            top_p,
+        )
+
+        # Stream responses to show progress - this is a generator function now
+        for response_chunk in response_gen:
+            updated_history = history.copy()
+            updated_history[-1] = {"role": "assistant", "content": response_chunk}
+            yield updated_history
+
+    except Exception as e:
+        logger.error(f"Error in bot_response: {e}")
+        import traceback
+
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        error_history = history.copy()
+        error_history[-1] = {"role": "assistant", "content": f"Error: {str(e)}"}
+        yield error_history
+
+
+def respond(
+    message,
+    history: list[tuple[str, str]],
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+) -> Generator[str, None, None]:
+    try:
+        # Start capturing logs for this session
+        start_session_logging()
+
+        # Reset tool assembler for new conversation
+        _tool_assembler.reset()
+
+        messages = [{"role": "system", "content": system_message}]
+
+        for val in history:
+            if val[0]:
+                messages.append({"role": "user", "content": val[0]})
+
+            if val[1]:
+                messages.append({"role": "assistant", "content": val[1]})
+
+        messages.append({"role": "user", "content": message})
+
+        # Check if this looks like a scheduling request
+        scheduling_keywords = [
+            "schedule",
+            "task",
+            "calendar",
+            "plan",
+            "organize",
+            "meeting",
+            "appointment",
+            "project",
+            "deadline",
+            "create",
+            "setup",
+            "implement",
+            "develop",
+        ]
+
+        is_scheduling_request = any(
+            keyword in message.lower() for keyword in scheduling_keywords
+        )
+
+        logger.info(f"Message: {message}")
+        logger.info(f"Is scheduling request: {is_scheduling_request}")
+
+        # Prepare payload for Nebius API
+        payload = {
+            "model": nebius_model,
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "top_p": top_p,
+            "stream": True,
+        }
+
+        # Add tools if this might be a scheduling request
+        if is_scheduling_request:
+            logger.info("Adding tools to payload")
+            payload["tools"] = _mcp_client.tools
+            payload["tool_choice"] = "auto"
+            logger.debug(f"Tools payload: {_mcp_client.tools}")
+
+        else:
+            logger.info("No scheduling detected, not adding tools")
+
+        headers = {
+            "Authorization": f"Bearer {nebius_api_key}",
+            "Content-Type": "application/json",
+        }
+
+        logger.info(
+            f"Sending request to Nebius API with tools: {is_scheduling_request}"
+        )
+        logger.debug(f"Full payload: {json.dumps(payload, indent=2)}")
+
+        response = requests.post(
+            "https://api.studio.nebius.ai/v1/chat/completions",
+            headers=headers,
+            json=payload,
+            stream=True,
+        )
+
+        if response.status_code != 200:
+            logger.error(f"API error: {response.status_code} - {response.text}")
+            yield f"Error: API returned {response.status_code}: {response.text}"
+            return
+
+        response_text = ""
+
+        # Initial yield to show streaming is working
+        if is_scheduling_request:
+            yield "🤖 **Processing your scheduling request...**"
+
+        for line in response.iter_lines():
+            if line:
+                line = line.decode("utf-8")
+                if line.startswith("data: "):
+                    data = line[6:]  # Remove 'data: ' prefix
+                    if data.strip() == "[DONE]":
+                        break
+                    try:
+                        chunk = json.loads(data)
+                        logger.debug(f"Received chunk: {chunk}")
+                        if "choices" in chunk and len(chunk["choices"]) > 0:
+                            delta = chunk["choices"][0].get("delta", {})
+                            content = delta.get("content", "")
+                            if content:
+                                response_text += content
+                                # For scheduling requests, include essential logs inline
+                                if is_scheduling_request:
+                                    session_logs = get_session_logs()
+                                    if session_logs:
+                                        # Show only new logs since last yield
+                                        latest_logs = (
+                                            session_logs[-3:]
+                                            if len(session_logs) > 3
+                                            else session_logs
+                                        )
+                                        logs_text = "\n".join(
+                                            f"  {log}" for log in latest_logs
+                                        )
+                                        yield response_text + f"\n\n{logs_text}"
+                                    else:
+                                        yield response_text
+                                else:
+                                    yield response_text
+
+                            # Process tool calls using our new handler
+                            _tool_assembler.process_delta(delta)
+
+                    except json.JSONDecodeError as e:
+                        logger.error(f"JSON decode error: {e} for line: {line}")
+                        continue
+
+        # Get completed tool calls and process them
+        completed_tool_calls = _tool_assembler.get_completed_tool_calls()
+
+        # Log debug info
+        debug_info = _tool_assembler.debug_info()
+        logger.info(f"Tool call assembly completed: {debug_info}")
+
+        if completed_tool_calls:
+            logger.info(f"Processing {len(completed_tool_calls)} completed tool calls")
+            yield response_text + "\n\n🔧 **Processing scheduling request...**"
+
+            # Process tool calls using our new processor
+            tool_response = _tool_processor.process_tool_calls(
+                completed_tool_calls, message
+            )
+            response_text += tool_response
+            yield response_text
+
+        else:
+            logger.info("No completed tool calls found")
+            if is_scheduling_request:
+                logger.warning(
+                    "Scheduling request detected but no completed tool calls"
+                )
+
+                # Log detailed debug info for troubleshooting
+                logger.error(f"Tool assembly debug info: {debug_info}")
+
+                yield response_text + "\n\n⚠️ **Scheduling request detected but tool not triggered or incomplete. Let me try calling the scheduler directly...**"
+
+                # Directly call the scheduling tool as fallback
+                try:
+                    # Extract task description from message
+                    task_description = message
+                    calendar_content = "none"
+
+                    # Extract calendar data if available
+                    calendar_match = re.search(r"\[CALENDAR_DATA:([^\]]+)\]", message)
+                    if calendar_match:
+                        calendar_content = calendar_match.group(1)
+
+                    # Show essential task processing logs inline
+                    session_logs = get_session_logs()
+                    processing_status = ""
+                    if session_logs:
+                        latest_logs = (
+                            session_logs[-2:] if len(session_logs) > 2 else session_logs
+                        )
+                        processing_status = "\n" + "\n".join(
+                            f"  {log}" for log in latest_logs
+                        )
+
+                    yield response_text + f"\n\n🔧 **Direct scheduling call for: {task_description}**\n⏳ *Processing...*{processing_status}"
+
+                    logger.info("About to call MCP scheduling tool directly")
+
+                    # Add timeout to prevent hanging
+                    import asyncio
+                    import concurrent.futures
+
+                    def call_with_timeout():
+                        try:
+                            return loop.run_until_complete(
+                                asyncio.wait_for(
+                                    _mcp_client.call_scheduling_tool(
+                                        task_description, calendar_content
+                                    ),
+                                    timeout=60.0,  # 60 second timeout
+                                )
+                            )
+                        except asyncio.TimeoutError:
+                            return {
+                                "error": "Timeout after 60 seconds",
+                                "status": "timeout",
+                            }
+
+                    # Show progress during processing with essential logs
+                    session_logs = get_session_logs()
+                    analysis_status = ""
+                    if session_logs:
+                        latest_logs = (
+                            session_logs[-3:] if len(session_logs) > 3 else session_logs
+                        )
+                        analysis_status = "\n" + "\n".join(
+                            f"  {log}" for log in latest_logs
+                        )
+
+                    yield response_text + f"\n\n🔧 **Direct scheduling call for: {task_description}**\n⏳ *Analyzing calendar and generating tasks...*{analysis_status}"
+
+                    try:
+                        result = call_with_timeout()
+                    except Exception as timeout_err:
+                        logger.error(
+                            f"MCP scheduling tool timed out or failed: {timeout_err}"
+                        )
+                        tool_response = f"\n\n⏰ **Scheduling timed out** - The request took longer than expected. Please try with a simpler task description."
+                        response_text += tool_response
+                        logger.info("Added timeout message to response")
+                        yield response_text
+                    else:
+                        # Show progress for result processing
+                        yield response_text + f"\n\n🔧 **Direct scheduling call for: {task_description}**\n⏳ *Processing results...*"
+
+                        logger.info(
+                            f"MCP tool completed with status: {result.get('status', 'unknown')}"
+                        )
+                        logger.info(f"MCP result type: {type(result)}")
+                        logger.info(
+                            f"MCP result keys: {list(result.keys()) if isinstance(result, dict) else 'Not a dict'}"
+                        )
+
+                        # Debug the result structure
+                        if isinstance(result, dict):
+                            logger.info(f"Result status: {result.get('status')}")
+                            logger.info(f"Result has schedule: {'schedule' in result}")
+                            logger.info(
+                                f"Result has calendar_entries: {'calendar_entries' in result}"
+                            )
+                            if "schedule" in result:
+                                logger.info(
+                                    f"Schedule length: {len(result.get('schedule', []))}"
+                                )
+                            if "calendar_entries" in result:
+                                logger.info(
+                                    f"Calendar entries length: {len(result.get('calendar_entries', []))}"
+                                )
+
+                        # Check multiple possible success conditions
+                        is_success = False
+                        success_msg = ""
+
+                        if result.get("status") == "success":
+                            is_success = True
+                            success_msg = "Status is 'success'"
+                        elif isinstance(result, dict) and "schedule" in result:
+                            is_success = True
+                            success_msg = "Result contains schedule data"
+                        elif isinstance(result, dict) and len(result) > 0:
+                            is_success = True
+                            success_msg = "Result contains data"
+
+                        logger.info(f"Success check: {is_success} ({success_msg})")
+
+                        if is_success:
+                            logger.info(
+                                "SUCCESS CONDITION MET - Processing successful result"
+                            )
+                            schedule = result.get("schedule", [])
+                            calendar_entries = result.get("calendar_entries", [])
+
+                            # Format the schedule as a table
+                            if schedule:
+                                # Create table header
+                                table_md = "\n\n## 📅 **Generated Schedule**\n\n"
+                                table_md += "| Start Time | End Time | Task | Project | Employee | Duration | Skill | Status |\n"
+                                table_md += "|------------|----------|------|---------|----------|----------|-------|--------|\n"
+
+                                # Add table rows
+                                for item in schedule:
+                                    # Use the correct field names from schedule_to_dataframe
+                                    start_time = item.get(
+                                        "Start", item.get("start_time", "N/A")
+                                    )
+                                    end_time = item.get(
+                                        "End", item.get("end_time", "N/A")
+                                    )
+                                    task_name = item.get(
+                                        "Task",
+                                        item.get(
+                                            "task_name", item.get("description", "N/A")
+                                        ),
+                                    )
+                                    project = item.get(
+                                        "Project", item.get("project", "N/A")
+                                    )
+                                    employee = item.get(
+                                        "Employee", item.get("employee", "N/A")
+                                    )
+                                    duration = item.get(
+                                        "Duration (hours)", item.get("duration", "N/A")
+                                    )
+                                    skill = item.get(
+                                        "Required Skill", item.get("skill", "N/A")
+                                    )
+
+                                    # Status indicators based on flags
+                                    status_flags = []
+                                    if item.get("Pinned", False):
+                                        status_flags.append("📌 Pinned")
+                                    if item.get("Unavailable", False):
+                                        status_flags.append("⚠️ Unavailable")
+                                    if item.get("Undesired", False):
+                                        status_flags.append("😐 Undesired")
+                                    if item.get("Desired", False):
+                                        status_flags.append("✅ Desired")
+
+                                    status = (
+                                        " ".join(status_flags)
+                                        if status_flags
+                                        else "⚪ Normal"
+                                    )
+
+                                    # Format dates/times if they are datetime strings
+                                    if isinstance(start_time, str) and "T" in str(
+                                        start_time
+                                    ):
+                                        try:
+                                            from datetime import datetime
+
+                                            dt = datetime.fromisoformat(
+                                                str(start_time).replace("Z", "+00:00")
+                                            )
+                                            start_time = dt.strftime("%m/%d %H:%M")
+                                        except:
+                                            pass
+
+                                    if isinstance(end_time, str) and "T" in str(
+                                        end_time
+                                    ):
+                                        try:
+                                            from datetime import datetime
+
+                                            dt = datetime.fromisoformat(
+                                                str(end_time).replace("Z", "+00:00")
+                                            )
+                                            end_time = dt.strftime("%m/%d %H:%M")
+                                        except:
+                                            pass
+
+                                    # Truncate long task names for table display
+                                    if len(str(task_name)) > 35:
+                                        task_name = str(task_name)[:32] + "..."
+
+                                    # Format duration
+                                    if isinstance(duration, (int, float)):
+                                        duration = f"{duration}h"
+
+                                    table_md += f"| {start_time} | {end_time} | {task_name} | {project} | {employee} | {duration} | {skill} | {status} |\n"
+
+                                table_md += f"\n**Summary:**\n"
+                                table_md += f"- 📊 **Total Items:** {len(schedule)}\n"
+                                table_md += f"- 📅 **Calendar Events:** {len(calendar_entries)}\n"
+                                table_md += f"- ✅ **Status:** Successfully scheduled around existing commitments\n"
+
+                                # Count different types of tasks
+                                pinned_count = sum(
+                                    1 for item in schedule if item.get("Pinned", False)
+                                )
+                                project_tasks = sum(
+                                    1
+                                    for item in schedule
+                                    if item.get("Project") == "PROJECT"
+                                )
+                                existing_events = sum(
+                                    1
+                                    for item in schedule
+                                    if item.get("Project") == "EXISTING"
+                                )
+
+                                table_md += f"- 📌 **Pinned Events:** {pinned_count}\n"
+                                table_md += f"- 🆕 **New Tasks:** {project_tasks}\n"
+                                table_md += (
+                                    f"- 📅 **Existing Events:** {existing_events}\n"
+                                )
+
+                                # Add JSON data section for debugging
+                                table_md += f"\n\n<details>\n<summary>📋 **Raw JSON Data** (click to expand)</summary>\n\n"
+                                table_md += "```json\n"
+                                table_md += safe_json_dumps(result)
+                                table_md += "\n```\n</details>\n"
+
+                                tool_response = table_md
+                            else:
+                                tool_response = f"""
+
+📅 **Schedule Generated Successfully!**
+
+**Task:** {task_description}
+**Calendar Events Processed:** {len(calendar_entries)}
+**Total Scheduled Items:** {len(schedule)}
+
+⚠️ **No schedule items to display** - This may indicate the task was completed or no scheduling was needed.
+
+**Raw Result:**
+```json
+{safe_json_dumps(result, indent=2)[:1000]}
+```
+"""
+
+                            response_text += tool_response
+                            logger.info("Added success message with table to response")
+                            yield response_text
+                        else:
+                            logger.warning(f"SUCCESS CONDITION NOT MET")
+                            error_msg = result.get(
+                                "error",
+                                f"Unknown error - result: {safe_json_dumps(result)[:200]}",
+                            )
+                            tool_response = f"\n\n❌ **Scheduling Error:** {error_msg}"
+                            response_text += tool_response
+                            logger.info("Added error message to response")
+                            yield response_text
+
+                except Exception as e:
+                    logger.error(f"Direct scheduling call failed: {e}")
+                    import traceback
+
+                    logger.error(f"Full traceback: {traceback.format_exc()}")
+                    tool_response = f"\n\n❌ **Scheduling failed:** {str(e)}"
+                    response_text += tool_response
+                    logger.info("Added exception message to response")
+                    yield response_text
+
+        # Always yield final response
+        logger.info(f"Final yield: response length {len(response_text)}")
+        yield response_text
+
+    except Exception as e:
+        logger.error(f"Error in chat response: {e}")
+        import traceback
+
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        yield f"Error: {str(e)}"

src/ui/pages/mcp_info.py

@@ -0,0 +1,136 @@
+import gradio as gr
+
+from utils.logging_config import setup_logging, get_logger
+
+# Initialize logging
+setup_logging()
+logger = get_logger(__name__)
+
+
+def draw_info_page(debug: bool = False):
+    with gr.Tab("📋 Use as MCP Tool"):
+
+        gr.Markdown(
+            """
+            ## 🔌 **Using as MCP Tool**
+
+            You can use Yuga Planner as an MCP server to integrate scheduling into your AI workflows.
+            """
+        )
+
+        gr.Textbox(
+            value=get_server_url(),
+            label="🌐 MCP Server Endpoint",
+            interactive=False,
+            max_lines=1,
+        )
+
+        with gr.Accordion("📝 MCP Setup Instructions", open=True):
+            gr.Markdown(
+                """
+                ### 1. **Cursor Setup Instructions (should work from any MCP client!)**
+
+                **For Cursor AI Editor:**
+                1. Create or edit your MCP configuration file: `~/.cursor/mcp.json`
+                2. Add the yuga-planner server configuration:
+                ```json
+                {
+                  "mcpServers": {
+                    "yuga-planner": {
+                      "url": -> "Insert the above endpoint URL here"
+                    }
+                  }
+                }
+                ```
+                3. If you already have other MCP servers, add `yuga-planner` to the existing `mcpServers` object
+                4. Restart Cursor to load the new configuration
+                5. The tool will be available in your chat
+
+                ### 2. **Usage Example**
+                """
+            )
+
+            gr.Textbox(
+                value="""use yuga-planner mcp tool
+Task Description: Create a new EC2 instance on AWS
+
+[Attach your calendar.ics file to provide existing commitments]
+
+Tool Response: Optimized schedule created - EC2 setup task assigned to
+available time slots around your existing meetings
+[Returns JSON response with schedule data]
+
+User: show all fields as a table, ordered by start date
+
+[Displays formatted schedule table with all tasks and calendar events]""",
+                label="💬 Cursor Chat Usage Example",
+                interactive=False,
+                lines=10,
+            )
+
+            gr.Markdown(
+                """
+                ### 3. **What it does**
+
+                **Personal Task Scheduling with Calendar Integration:**
+
+                1. 📅 **Parses your calendar** (.ics file) for existing commitments
+                2. 🤖 **AI breaks down your task** into actionable subtasks using LLamaIndex + Nebius AI
+                3. ⚡ **Constraint-based optimization** finds optimal time slots around your existing schedule
+                4. 📋 **Returns complete solved schedule** integrated with your personal calendar events
+                5. 🕘 **Respects business hours** (9:00-18:00) and excludes weekends automatically
+                6. 📊 **JSON response format** - Ask to "show all fields as a table, ordered by start date" for readable formatting
+
+                **Designed for**: Personal productivity and task planning around existing appointments in Cursor.
+                """
+            )
+
+        if debug:
+            with gr.Tab("🐛 Debug Info"):
+                gr.Markdown(
+                    """
+                    # 🐛 Debug Information
+
+                    **Debug Mode Enabled** - Additional system information and controls available.
+                    """
+                )
+
+                with gr.Accordion("🔧 **Environment Details**", open=True):
+                    import os
+
+                    env_info = f"""
+                    **🐍 Python Environment**
+                    - Debug Mode: {debug}
+                    - YUGA_DEBUG: {os.getenv('YUGA_DEBUG', 'Not Set')}
+                    - Nebius API Key: {'✅ Set' if os.getenv('NEBIUS_API_KEY') else '❌ Not Set'}
+                    - Nebius Model: {os.getenv('NEBIUS_MODEL', 'Not Set')}
+
+                    **🌐 Server Information**
+                    - MCP Endpoint: {get_server_url()}
+                    - Current Working Directory: {os.getcwd()}
+                    """
+                    gr.Markdown(env_info)
+
+                with gr.Accordion("📊 **System Status**", open=False):
+                    gr.Markdown(
+                        """
+                        **🔄 Service Status**
+                        - DataService: ✅ Active
+                        - ScheduleService: ✅ Active
+                        - StateService: ✅ Active
+                        - LoggingService: ✅ Active
+                        - MockProjectService: ✅ Active
+
+                        **🔌 Integration Status**
+                        - MCP Server: ✅ Enabled
+                        - Gradio API: ✅ Active
+                        - Real-time Logs: ✅ Streaming
+                        """
+                    )
+
+
+def get_server_url():
+    try:
+        return gr.get_state().server_url + "/gradio_api/mcp/sse"
+    except:
+        return "https://blackopsrepl-yuga-planner.hf.space/gradio_api/mcp/sse"

tests/test_json_repair.py

@@ -0,0 +1,179 @@
+import json
+import sys
+
+
+# Add src to path to import our modules
+sys.path.insert(0, "src")
+
+from handlers.tool_call_handler import ToolCallAssembler
+
+# Import standardized test utilities
+from tests.test_utils import get_test_logger, create_test_results
+
+# Initialize standardized test logger
+logger = get_test_logger(__name__)
+
+
+def test_actual_streaming_error():
+    """Test the JSON repair functionality with the actual streaming error pattern"""
+
+    logger.start_test("Testing JSON repair functionality with actual streaming error")
+
+    # This is based on the actual error from the logs at character 787
+    # The pattern shows base64 data ending abruptly with a quote and then a duplicate JSON object
+    broken_json = """{"task_description":"create ec2 on aws","calendar_file_content":"QkVHSU46VkNBTEVOREFSClZFUlNJT046Mi4wClBST0RJRDotLy9pY2FsLm1hcnVkb3QuY29tLy9pQ2FsIEV2ZW50IE1ha2VyCkNBTFNDQUxFOkdSRUdPUklBTgpCRUdJTjpWVElNRVpPTkUKVFpJRDpBZnJpY2EvTGFnb3MKTEFTVC1NT0RJRklFRDoyMDI0MDQyMlQwNTM0NTBaClRaVVJMOmh0dHBzOi8vd3d3LnR6dXJsLm9yZy96b25laW5mby1vdXRsb29rL0FmcmljYS9MYWdvcwpYLUxJQy1MT0NBVElPTjpBZnJpY2EvTGFnb3MKQkVHSU46U1RBTkRBUkQKVFpOQU1FOldBVApUWk9GRlNFVEZST006KzAxMDAKVFpPRkZTRVRUTzorMDEwMApEVFNUQVJUOjE5NzAwMTAxVDAwMDAwMApFTkQ6U1RBTkRBUkQKRU5EOlZUSU1FWk9ORQpCRUdJTjpWRVZFTlQKRFRTVEFNUDoyMDI1MDYyMFQxMzQxMjBaClVJRDpyZWN1ci1tZWV0aW5nLTJAbW9jawpEVFNUQVJUO1RaSUQ9QWZyaWNhL0xhZ29zOjIwMjUwNjAyVDE1MDAwMApEVEVORDtUWklEPUFmcmljYS9MYWdvczoyMDI1MDYwMlQxNjAwMDAKU1VNTUFSWTpQcm9qZWN0IFJldmlldwpFTkQ6VkVWRU5UCkJFR0lOO"{"task_description":"create ec2 on aws","calendar_file_content":"QkVHSU46VkNBTEVOREFSClZFUlNJT046Mi4wClBST0RJRDotLy9pY2FsLm1hcnVkb3QuY29tLy9pQ2FsIEV2ZW50IE1ha2VyCkNBTFNDQUxFOkdSRUdPUklBTgpCRUdJTjpWVElNRVpPTkUKVFpJRDpBZnJpY2EvTGFnb3MKTEFTVC1NT0RJRklFRDoyMDI0MDQyMlQwNTM0NTBaClRaVVJMOmh0dHBzOi8vd3d3LnR6dXJsLm9yZy96b25laW5mby1vdXRsb29rL0FmcmljYS9MYWdvcwpYLUxJQy1MT0NBVElPTjpBZnJpY2EvTGFnb3MKQkVHSU46U1RBTkRBUkQKVFpOQU1FOldBVApUWk9GRlNFVEZST006KzAxMDAKVFpPRkZTRVRUTzorMDEwMApEVFNUQVJUOjE5NzAwMTAxVDAwMDAwMApFTkQ6U1RBTkRBUkQKRU5EOlZUSU1FWk9ORQpCRUdJTjpWRVZFTlQKRFRTVEFNUDoyMDI1MDYyMFQxMzQxMjBaClVJRDpyZWN1ci1tZWV0aW5nLTFAbW9jawpEVFNUQVJUO1RaSUQ9QWZyaWNhL0xhZ29zOjIwMjUwNjAzVDEwMDAwMApEVEVORDtUWklEPUFmcmljYS9MYWdvczoyMDI1MDYwM1QxMTAwMDAKU1VNTUFSWTpUZWFtIFN5bmMKRU5EOlZFVkVOVApCRUdJTjpWRVZFTlQKRFRTVEFNUDoyMDI1MDYyMFQxMzQxMjBaClVJRDpzaW5nbGUtZXZlbnQtMUBtb2NrCkRUU1RBUlQ7VFpJRD1BZnJpY2EvTGFnb3M6MjAyNTA2MDVUMTQwMDAwCkRURU5EO1RaSUQ9QWZyaWNhL0xhZ29zOjIwMjUwNjA1VDE1MDAwMApTVU1NQVJZOkNsaWVudCBDYWxsCkVORDpWRVZFTlQKQkVHSU46VkVWRU5UCkRUU1RBTVA6MjAyNTA2MjBUMTM0MTIwWgpVSUQ6c2luZ2xlLWV2ZW50LTRAbW9jawpEVFNUQVJUO1RaSUQ9QWZyaWNhL0xhZ29zOjIwMjUwNjE2VDE2MDAwMApEVEVORDtUWklEPUFmcmljYS9MYWdvczoyMDI1MDYxNlQxNzAwMDAKU1VNTUFSWTpXb3Jrc2hvcApFTkQ6VkVWRU5UCkJFR0lOOlZFVkVOVApEVFNUQU1QOjIwMjUwNjIwVDEzNDEyMFoKVUlEOnNpbmdsZS1ldmVudC0zQG1vY2sKRFRTVEFSVDtUWklEPUFmcmljYS9MYWdvczoyMDI1MDcwN1QxMTAwMDAKRFRFTkQ7VFpJRD1BZnJpY2EvTGFnb3M6MjAyNTA3MDdUMTIwMDAwClNVTU1BUlk6UGxhbm5pbmcgU2Vzc2lvbgpFTkQ6VkVWRU5UCkJFR0lOOlZFVkVOVApEVFNUQU1QOjIwMjUwNjIwVDEzNDEyMFoKVUlEOnNpbmdsZS1ldmVudC01QG1vY2sKRFRTVEFSVDtUWklEPUFmcmljYS9MYWdvczoyMDI1MDcyMlQwOTAwMDAKRFRFTkQ7VFpJRD1BZnJpY2EvTGFnb3M6MjAyNTA3MjJUMTAwMDAwClNVTU1BUlk6RGVtbwpFTkQ6VkVWRU5UCkVORDpWQ0FMRU5EQVI="}"""
+
+    logger.debug(f"Broken JSON length: {len(broken_json)}")
+
+    # Find the error position (where the duplicate starts)
+    error_pos = broken_json.find(';"{"task_description"')
+    logger.debug(f"Error position (duplicate JSON start): {error_pos}")
+
+    # Try to parse the broken JSON first to confirm it fails
+    json_parse_failed = False
+    try:
+        json.loads(broken_json)
+        logger.error("❌ UNEXPECTED: Broken JSON parsed successfully!")
+    except json.JSONDecodeError as e:
+        json_parse_failed = True
+        logger.info(f"✅ Expected JSON error at position {e.pos}: {e}")
+        logger.debug(f"Error context: '{broken_json[max(0, e.pos-20):e.pos+20]}'")
+
+    assert json_parse_failed, "Expected broken JSON to fail parsing"
+
+    # Test the repair function
+    assembler = ToolCallAssembler()
+    repaired_json = assembler._attempt_json_repair(broken_json)
+
+    assert repaired_json is not None, "Repair should return a result"
+
+    logger.info(f"✅ Repair attempted, result length: {len(repaired_json)}")
+    logger.debug(f"Repaired preview: {repaired_json[:200]}...")
+
+    # Try to parse the repaired JSON
+    parsed = json.loads(repaired_json)
+    logger.debug(f"Task description: {parsed.get('task_description', 'MISSING')}")
+    logger.debug(
+        f"Calendar content length: {len(parsed.get('calendar_file_content', ''))}"
+    )
+
+    # Verify expected fields exist
+    assert "task_description" in parsed, "Repaired JSON should have task_description"
+    assert (
+        "calendar_file_content" in parsed
+    ), "Repaired JSON should have calendar_file_content"
+    assert (
+        parsed["task_description"] == "create ec2 on aws"
+    ), "Task description should match expected value"
+
+    logger.pass_test("Repaired JSON parses correctly")
+
+
+def test_simpler_corruption():
+    """Test a simpler case of JSON corruption for baseline functionality"""
+
+    logger.start_test("Testing simpler JSON corruption")
+
+    # Missing closing brace
+    simple_broken = (
+        '{"task_description":"test task","calendar_file_content":"base64data"'
+    )
+
+    assembler = ToolCallAssembler()
+    repaired = assembler._attempt_json_repair(simple_broken)
+
+    assert repaired is not None, "Simple repair should return a result"
+
+    # Try to parse the repaired JSON
+    parsed = json.loads(repaired)
+
+    assert (
+        "task_description" in parsed
+    ), "Simple repair should preserve task_description"
+    assert parsed["task_description"] == "test task", "Task description should match"
+
+    logger.pass_test("Simple repair works correctly")
+
+
+def test_datetime_serialization():
+    """Test our datetime serialization fixes"""
+
+    logger.start_test("Testing datetime serialization")
+
+    # Import our safe serialization function
+    from ui.pages.chat import safe_json_dumps
+    from datetime import datetime
+
+    test_data = {
+        "schedule": [
+            {
+                "task": "Test Task",
+                "start_time": datetime(2025, 6, 23, 10, 0),
+                "end_time": datetime(2025, 6, 23, 11, 0),
+            }
+        ],
+        "timestamp": datetime.now(),
+    }
+
+    result = safe_json_dumps(test_data, indent=2)
+    logger.debug(f"Sample output: {result[:200]}...")
+
+    # Verify it's valid JSON
+    parsed_back = json.loads(result)
+    assert "schedule" in parsed_back, "Serialized result should have schedule"
+    assert "timestamp" in parsed_back, "Serialized result should have timestamp"
+    assert len(parsed_back["schedule"]) == 1, "Schedule should have one item"
+
+    logger.pass_test("Datetime serialization works correctly")
+
+
+def test_gradio_format():
+    """Test that we're returning the correct format for Gradio messages"""
+
+    logger.start_test("Testing Gradio message format")
+
+    # Simulate a proper messages format
+    test_history = [
+        {"role": "user", "content": "Hello"},
+        {"role": "assistant", "content": "Hi there!"},
+        {"role": "user", "content": "Create a schedule"},
+    ]
+
+    # This is what our function should return
+    expected_format = [
+        {"role": "user", "content": "Hello"},
+        {"role": "assistant", "content": "Hi there!"},
+        {"role": "user", "content": "Create a schedule"},
+        {"role": "assistant", "content": "Schedule created successfully!"},
+    ]
+
+    logger.debug("Expected format is list of dicts with 'role' and 'content' keys")
+
+    # Validate the format
+    for i, msg in enumerate(expected_format):
+        assert isinstance(msg, dict), f"Message {i} should be a dict, got {type(msg)}"
+        assert "role" in msg, f"Message {i} should have 'role' key"
+        assert "content" in msg, f"Message {i} should have 'content' key"
+        assert msg["role"] in [
+            "user",
+            "assistant",
+        ], f"Message {i} has invalid role: {msg['role']}"
+
+    logger.pass_test("Message format is correct for Gradio")
+
+
+if __name__ == "__main__":
+    logger.section("JSON Repair and Chat Functionality Tests")
+
+    # Create test results tracker
+    results = create_test_results(logger)
+
+    # Run tests using the standardized approach
+    results.run_test("streaming_error_repair", test_actual_streaming_error)
+    results.run_test("simple_json_repair", test_simpler_corruption)
+    results.run_test("datetime_serialization", test_datetime_serialization)
+    results.run_test("gradio_message_format", test_gradio_format)
+
+    # Generate summary and exit with appropriate code
+    all_passed = results.summary()
+    sys.exit(0 if all_passed else 1)

tests/test_tool_assembly.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+Test script for tool call assembly logic
+"""
+
+import json
+import sys
+import os
+
+# Add src to path so we can import modules
+sys.path.insert(0, "src")
+
+from handlers.tool_call_handler import ToolCallAssembler
+
+# Import standardized test utilities
+from tests.test_utils import get_test_logger, create_test_results
+
+# Initialize standardized test logger
+logger = get_test_logger(__name__)
+
+
+def test_tool_call_assembly():
+    """Test the tool call assembler with sample streaming data"""
+
+    logger.start_test("Testing Tool Call Assembly Logic")
+
+    assembler = ToolCallAssembler()
+
+    # Simulate streaming deltas like we saw in the logs
+    sample_deltas = [
+        # Initial tool call with ID
+        {
+            "tool_calls": [
+                {
+                    "index": 0,
+                    "id": "chatcmpl-tool-ca3c56dcd04049cd8baf9a2cde4205d6",
+                    "function": {"name": "schedule_tasks_with_calendar"},
+                    "type": "function",
+                }
+            ]
+        },
+        # Arguments coming in chunks
+        {"tool_calls": [{"index": 0, "function": {"arguments": '{"task_description'}}]},
+        {"tool_calls": [{"index": 0, "function": {"arguments": '":"create an'}}]},
+        {
+            "tool_calls": [
+                {"index": 0, "function": {"arguments": " engaging gradio ui"}}
+            ]
+        },
+        {
+            "tool_calls": [
+                {
+                    "index": 0,
+                    "function": {
+                        "arguments": ' for yuga","calendar_file_content":"test123"}'
+                    },
+                }
+            ]
+        },
+    ]
+
+    logger.debug("Processing streaming deltas...")
+    for i, delta in enumerate(sample_deltas):
+        logger.debug(f"  Delta {i+1}: {delta}")
+        assembler.process_delta(delta)
+
+        # Show debug info after each delta
+        debug_info = assembler.debug_info()
+        logger.debug(
+            f"    -> Tool calls: {debug_info['total_tool_calls']}, Completed: {debug_info['completed_tool_calls']}"
+        )
+
+        if debug_info["tool_calls_detail"]:
+            for idx, detail in debug_info["tool_calls_detail"].items():
+                logger.debug(
+                    f"    -> Tool {idx}: {detail['function_name']}, Args valid: {detail['is_json_valid']}"
+                )
+                logger.debug(f"       Args preview: {detail['arguments_preview']}")
+
+    completed_calls = assembler.get_completed_tool_calls()
+    logger.info(f"✅ Completed tool calls: {len(completed_calls)}")
+
+    for i, tool_call in enumerate(completed_calls):
+        logger.debug(f"Tool Call {i+1}:")
+        logger.debug(f"  ID: {tool_call['id']}")
+        logger.debug(f"  Function: {tool_call['function']['name']}")
+        logger.debug(f"  Arguments: {tool_call['function']['arguments']}")
+
+        # Try to parse arguments
+        try:
+            args = json.loads(tool_call["function"]["arguments"])
+            logger.debug(f"  ✅ JSON Valid: {args}")
+
+        except json.JSONDecodeError as e:
+            logger.error(f"  ❌ JSON Invalid: {e}")
+            raise AssertionError(f"Tool call {i+1} has invalid JSON: {e}")
+
+    # Verify we got expected results
+    assert len(completed_calls) > 0, "Should have at least one completed tool call"
+
+    logger.pass_test("Normal tool call assembly works correctly")
+
+
+def test_broken_json():
+    """Test with broken JSON to see how we handle it"""
+
+    logger.start_test("Testing Broken JSON Handling")
+
+    assembler = ToolCallAssembler()
+
+    # Simulate incomplete/broken JSON
+    broken_deltas = [
+        {
+            "tool_calls": [
+                {
+                    "index": 0,
+                    "id": "test-broken",
+                    "function": {"name": "schedule_tasks_with_calendar"},
+                    "type": "function",
+                }
+            ]
+        },
+        {
+            "tool_calls": [
+                {"index": 0, "function": {"arguments": '{"task_description":"test'}}
+            ]
+        },
+        # Missing closing quote and brace - should be invalid JSON
+    ]
+
+    for delta in broken_deltas:
+        assembler.process_delta(delta)
+
+    completed_calls = assembler.get_completed_tool_calls()
+    debug_info = assembler.debug_info()
+
+    logger.debug(f"Broken JSON Test Results:")
+    logger.debug(f"  Total tool calls: {debug_info['total_tool_calls']}")
+    logger.debug(f"  Completed (valid JSON): {len(completed_calls)}")
+    logger.debug(f"  Expected: 0 completed (due to broken JSON)")
+
+    for idx, detail in debug_info["tool_calls_detail"].items():
+        logger.debug(f"  Tool {idx}: JSON valid = {detail['is_json_valid']}")
+        logger.debug(f"    Args: {detail['arguments_preview']}")
+
+    # Should be 0 due to invalid JSON
+    expected_completed = 0
+    assert (
+        len(completed_calls) == expected_completed
+    ), f"Expected {expected_completed} completed calls due to broken JSON, got {len(completed_calls)}"
+
+    logger.pass_test("Broken JSON handling works correctly")
+
+
+if __name__ == "__main__":
+    logger.section("Tool Call Assembly Test Suite")
+    logger.info("Testing the isolated tool call assembly logic...")
+
+    # Create test results tracker
+    results = create_test_results(logger)
+
+    # Run tests using the standardized approach
+    results.run_test("normal_assembly", test_tool_call_assembly)
+    results.run_test("broken_json_handling", test_broken_json)
+
+    # Generate summary and exit with appropriate code
+    all_passed = results.summary()
+
+    if all_passed:
+        logger.info(
+            "🎉 All tests passed! Tool call assembly logic is working correctly."
+        )
+
+    else:
+        logger.error("💥 Some tests failed. Check the logic above.")
+
+    sys.exit(0 if all_passed else 1)