feat: Fix Gradio app integration and enhance console logging

✨ Major Improvements:
- Fixed message passing issue in Gradio chat interface
- Added real-time console logging with auto-refresh
- Enhanced log display with better scrolling and formatting
- Fixed database column name from distributor_price to distributor_pricing
- Improved system prompt for more proactive database searches
- Added comprehensive log capturing from external libraries

🐛 Bug Fixes:
- Resolved empty message issue in Gradio conversation flow
- Fixed tool invocation in web interface
- Corrected database schema references in system prompt

🎨 UI Enhancements:
- Added auto-refresh checkbox for real-time log updates
- Improved console styling with custom scrollbars
- Enhanced log display with 1000 entry capacity
- Better visual formatting and readability

🔧 Technical:
- Added GradioLogHandler for capturing external library logs
- Improved conversation state management
- Enhanced error handling and debugging capabilities

src/sales_assistant/agent_tools/create_quote.py

@@ -272,15 +272,21 @@ def create_quote(
         greeting = generate_dynamic_content(greeting_prompt)
         
         # Generate introduction
-        product_summary = ", ".join([item.product_name for item in quote_items[:3]])
-        if len(quote_items) > 3:
-            product_summary += f" and {len(quote_items) - 3} other item(s)"
+        detailed_product_list = []
+        for item in quote_items:
+            if item.quantity > 1:
+                detailed_product_list.append(f"{item.quantity}x {item.product_name}")
+            else:
+                detailed_product_list.append(item.product_name)
+        
+        product_list_str = ", ".join(detailed_product_list)
             
         intro_prompt = INTRO_PROMPT.format(
             customer_name=customer_name,
             company=customer_company or "your organization",
-            product_summary=product_summary,
-            item_count=len(quote_items)
+            detailed_product_list=product_list_str,
+            unique_product_count=len(unique_product_ids),
+            total_item_count=sum(product_quantities.values())
         )
         introduction = generate_dynamic_content(intro_prompt)
         

src/sales_assistant/agent_tools/quote_template.py

@@ -73,17 +73,20 @@ Company: {company}
 """
 
 INTRO_PROMPT = """
-Generate a professional introduction paragraph (2-3 sentences) for a sales quote.
+Generate a professional introduction paragraph (4-6 sentences) for a sales quote.
 The introduction should:
-- Reference the products being quoted
-- Express confidence in meeting their needs
-- Be professional but friendly
-- Be concise (max 3 sentences)
+- Reference the specific products being quoted with their names
+- Highlight key benefits or features of the product categories
+- Express confidence in meeting their needs and providing value
+- Mention the comprehensive nature of the solution if multiple products
+- Be professional but friendly and engaging
+- Be detailed but concise (4-6 sentences maximum)
 
 Customer: {customer_name}
 Company: {company}
-Products being quoted: {product_summary}
-Number of items: {item_count}
+Products being quoted: {detailed_product_list}
+Number of different products: {unique_product_count}
+Total items: {total_item_count}
 
 Generate only the introduction paragraph, no additional formatting.
 """
@@ -137,15 +140,35 @@ def generate_product_description(product_info: dict, llm) -> str:
         return original_desc
 
 
+def format_currency_number(amount: float, currency: str) -> str:
+    """Format currency amount as integer without symbol."""
+    if amount is None or amount == 0:
+        return "0"
+    
+    # Round to integer
+    rounded_amount = round(amount)
+    
+    if currency == "HUF":
+        return f"{rounded_amount:,}"
+    else:
+        return f"{rounded_amount:,}"
+
+
 def format_currency(amount: float, currency: str) -> str:
-    """Format currency amount with proper symbol."""
+    """Format currency amount with proper symbol - kept for backward compatibility."""
+    if amount is None or amount == 0:
+        symbols = {"EUR": "€", "USD": "$", "HUF": "Ft"}
+        symbol = symbols.get(currency, currency)
+        return f"0 {symbol}" if currency == "HUF" else f"{symbol}0"
+    
     symbols = {"EUR": "€", "USD": "$", "HUF": "Ft"}
     symbol = symbols.get(currency, currency)
+    rounded_amount = round(amount)
     
     if currency == "HUF":
-        return f"{amount:,.0f} {symbol}"
+        return f"{rounded_amount:,} {symbol}"
     else:
-        return f"{symbol}{amount:,.2f}"
+        return f"{symbol}{rounded_amount:,}"
 
 
 def generate_markdown_quote(quote: Quote) -> str:
@@ -163,23 +186,31 @@ def generate_markdown_quote(quote: Quote) -> str:
     if quote.customer.email:
         customer_section += f"  \n📧 {quote.customer.email}"
     
-    # Create Markdown table for products
+    # Create Markdown table for products with currency column
     markdown_table = """
-| Product Name | Product ID | Description | Quantity | Unit Price | Total Price |
-|--------------|------------|-------------|----------|------------|-------------|
+| Product Name | Product ID | Description | Quantity | Unit Price | Currency | Total Price |
+|--------------|------------|-------------|----------|------------|----------|-------------|
 """
     
     for item in quote.items:
         # Clean description for table (remove line breaks but keep full text)
         clean_desc = item.description.replace('\n', ' ').replace('\r', ' ')
         
-        unit_price_str = format_currency(item.unit_price, quote.currency)
-        total_price_str = format_currency(item.total_price, quote.currency)
+        # Handle missing prices
+        if item.unit_price is None or item.unit_price == 0:
+            unit_price_str = "TBD"
+            total_price_str = "TBD"
+        else:
+            unit_price_str = format_currency_number(item.unit_price, quote.currency)
+            total_price_str = format_currency_number(item.total_price, quote.currency)
         
-        markdown_table += f"| {item.product_name} | {item.display_product_id} | {clean_desc} | {item.quantity} | {unit_price_str} | {total_price_str} |\n"
+        markdown_table += f"| {item.product_name} | {item.display_product_id} | {clean_desc} | {item.quantity} | {unit_price_str} | {quote.currency} | {total_price_str} |\n"
     
-    # Grand total
-    grand_total_str = format_currency(quote.grand_total, quote.currency)
+    # Grand total - handle case where some prices might be missing
+    if any(item.unit_price is None or item.unit_price == 0 for item in quote.items):
+        grand_total_str = f"TBD ({quote.currency})"
+    else:
+        grand_total_str = format_currency(quote.grand_total, quote.currency)
     
     # Complete Markdown template
     markdown_template = f"""# Professional Product Quotation

src/sales_assistant/prompts/system_prompt.py

@@ -19,14 +19,16 @@ Help users explore products in a MySQL database and provide comprehensive sales
 </reasoning>
 
 ## Exploration Strategy
-1. **Start Broad**: Begin with manufacturer/category exploration when user intent is unclear, check table schema if needed, check samples if needed
-2. **Go Specific**: Use model names, numbers, or descriptions for targeted searches  
-3. **Be Creative**: Different manufacturers categorize differently - adapt your SQL approach
-4. **Think Iteratively**: Use multiple queries to build a complete picture
+1. **Take Immediate Action**: When users ask about specific products, search directly using the product name/model
+2. **Be Proactive**: Use SQL queries to search for products immediately rather than asking for clarification
+3. **Search Creatively**: Use LIKE patterns to find products by name, model, or description
+4. **Start with Direct Search**: Search by product name first, then explore broader categories if nothing found
+5. **Think Iteratively**: Use multiple queries to build a complete picture
 
 ## Key Guidelines
+- **Take Direct Action**: When users ask about specific products, immediately search the database
 - **Leverage Tool Descriptions**: Each tool has comprehensive examples - use them as guidance
-- **Start with Database Exploration**: When unsure, explore structure first using the sql tool
+- **Search First, Ask Later**: Attempt to find products before asking for clarification
 - **Use Reasoning Annotations**: Think through your approach step-by-step
 - **Provide Specific Details**: Include pricing, model numbers, and specifications when available
 - **Ask Clarifying Questions**: If user intent is unclear after initial exploration
@@ -43,7 +45,7 @@ Focus on reasoning through the user's request and choosing the right tool with a
 
 ## Important Notes:
 - You are optimized for GPT-5-mini with advanced reasoning capabilities.
-- when a user asks product information use: id, model_number_short, model_number_long, manufacturer, model_name, category, sub_category, distributor_price, msrp, currency, description as much as possible to give a complete answer summerizing the product information based on this (just and example do not need to always use all).
+- when a user asks product information use: id, model_number_short, model_number_long, manufacturer, model_name, category, sub_category, distributor_pricing, msrp, currency, description as much as possible to give a complete answer summerizing the product information based on this (just and example do not need to always use all).
 - or if a user asks for shorter answer you can leave out some of the fields.
 - description can be summarized do not write out what is there use your common senese
 - Use LIMITS in your SQL queries to avoid overwhelming results to use less tokens, if you need more results you can always ask for more.

src/sales_assistant/ui_dashboard/gradio_app.py

@@ -9,6 +9,10 @@ import gradio as gr
 from typing import List, Tuple, Dict
 from datetime import datetime
 import glob
+import threading
+import time
+import logging
+import io
 
 # Add the src directory to the path
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
@@ -23,6 +27,32 @@ from sales_assistant.agent_main.agent_runner import (
 )
 
 
+class GradioLogHandler(logging.Handler):
+    """Custom log handler to capture all logs for Gradio console."""
+    
+    def __init__(self, chat_assistant):
+        super().__init__()
+        self.chat_assistant = chat_assistant
+        
+    def emit(self, record):
+        try:
+            # Format the log message
+            log_entry = self.format(record)
+            # Add to Gradio console (without timestamp since we add our own)
+            if hasattr(self.chat_assistant, 'console_logs'):
+                timestamp = datetime.now().strftime("%H:%M:%S")
+                level = record.levelname
+                message = record.getMessage()
+                formatted_entry = f"[{timestamp}] {level}: {message}"
+                self.chat_assistant.console_logs.append(formatted_entry)
+                
+                # Keep only the last max_logs entries
+                if len(self.chat_assistant.console_logs) > self.chat_assistant.max_logs:
+                    self.chat_assistant.console_logs.pop(0)
+        except Exception:
+            pass  # Ignore errors in logging
+
+
 class SalesAssistantChat:
     """Chat interface for the sales assistant."""
     
@@ -33,8 +63,53 @@ class SalesAssistantChat:
         self.callback_manager = None
         self.thread_id = None
         self.quotes_dir = os.path.join(os.path.dirname(__file__), '../created_quotes')
+        self.console_logs = []
+        self.max_logs = 1000  # Increased from 500 to store more logs
+        self.current_message = ""  # Store current message for processing
+        
+        # Set up logging to capture external logs
+        self.setup_logging()
         self.initialize_agent()
     
+    def setup_logging(self):
+        """Set up logging to capture all relevant logs."""
+        # Create custom handler
+        self.log_handler = GradioLogHandler(self)
+        formatter = logging.Formatter('%(name)s: %(message)s')
+        self.log_handler.setFormatter(formatter)
+        
+        # Add handler to relevant loggers
+        loggers_to_capture = [
+            'sales_assistant.agent_tools.agent_tools_utils',
+            'paramiko.transport',
+            'sshtunnel',
+            'httpx',
+            'src.sales_assistant.agent_tools.agent_tools_utils'
+        ]
+        
+        for logger_name in loggers_to_capture:
+            logger = logging.getLogger(logger_name)
+            logger.addHandler(self.log_handler)
+            logger.setLevel(logging.INFO)
+    
+    def log_to_console(self, message: str, level: str = "INFO"):
+        """Add a message to console logs with timestamp."""
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        log_entry = f"[{timestamp}] {level}: {message}"
+        self.console_logs.append(log_entry)
+        
+        # Keep only the last max_logs entries
+        if len(self.console_logs) > self.max_logs:
+            self.console_logs.pop(0)
+        
+        print(log_entry)  # Also print to actual console
+    
+    def get_console_logs(self) -> str:
+        """Get formatted console logs."""
+        if not self.console_logs:
+            return "No logs available yet..."
+        return "\n".join(self.console_logs)  # Show all logs instead of just last 20
+    
     def get_quote_files(self) -> List[Tuple[str, str, str]]:
         """Get list of quote files with metadata."""
         quote_files = []
@@ -74,69 +149,117 @@ class SalesAssistantChat:
     def initialize_agent(self):
         """Initialize the agent runner."""
         try:
+            self.log_to_console("Starting agent initialization...")
+            
             # Check environment setup
             if not check_environment_setup():
-                print("❌ Environment setup failed")
+                self.log_to_console("Environment setup failed", "ERROR")
                 return
             
-            # Create configuration
+            self.log_to_console("Environment setup completed")
+            
+            # Create configuration with unique session ID
+            import uuid
+            unique_session_id = f"gradio_session_{uuid.uuid4().hex[:8]}"
             config = create_custom_config(
-                session_id="gradio_session",
+                session_id=unique_session_id,
                 user_id="gradio_user",
                 enable_langsmith=True
             )
             
+            self.log_to_console(f"Configuration created with session: {unique_session_id}")
+            
             # Create agent runner
             self.compiled_graph, self.checkpointer, self.callback_manager, self.thread_id = create_agent_runner(config)
-            print("✅ Sales Assistant initialized successfully!")
+            self.log_to_console("Sales Assistant initialized successfully!", "SUCCESS")
             
         except Exception as e:
-            print(f"❌ Failed to initialize sales assistant: {e}")
+            self.log_to_console(f"Failed to initialize sales assistant: {e}", "ERROR")
             self.compiled_graph = None
     
-    def chat_function(self, message: str, history: List[Dict[str, str]]) -> Tuple[str, List[Dict[str, str]], List[Tuple[str, str, str]]]:
+    def chat_function_immediate(self, message: str, history: List[Dict[str, str]]) -> Tuple[str, List[Dict[str, str]], str]:
         """
-        Process a chat message and return the response.
+        Immediately show user message and loading indicator.
+        
+        Returns:
+            Tuple of (empty_string, updated_history_with_loading, console_logs)
+        """
+        if not message.strip():
+            return "", history, self.get_console_logs()
+        
+        # Store the message for later processing
+        self.current_message = message
+        
+        # Immediately add user message and loading indicator
+        history.append({"role": "user", "content": message})
+        history.append({"role": "assistant", "content": "🤔 Thinking... Please wait while I process your request."})
+        
+        self.log_to_console(f"User message received: {message[:50]}...")
+        
+        return "", history, self.get_console_logs()
+    
+    def chat_function_process(self, message: str, history: List[Dict[str, str]]) -> Tuple[str, List[Dict[str, str]], List[Tuple[str, str, str]], str]:
+        """
+        Process the actual chat message and return the response.
         
-        Args:
-            message: User's input message
-            history: Chat history as list of message dictionaries
-            
         Returns:
-            Tuple of (empty_string, updated_history, updated_quote_files)
+            Tuple of (empty_string, updated_history, updated_quote_files, console_logs)
         """
+        # Use the stored message instead of the parameter (which might be empty)
+        actual_message = self.current_message if self.current_message else message
+        
         if not self.compiled_graph:
             error_response = "❌ Sales Assistant is not properly initialized. Please check your environment configuration."
-            history.append({"role": "user", "content": message})
-            history.append({"role": "assistant", "content": error_response})
-            return "", history, self.get_quote_files()
-        
+            # Replace the loading message with error
+            if history and history[-1]["role"] == "assistant":
+                history[-1] = {"role": "assistant", "content": error_response}
+            
+            self.log_to_console("Agent not initialized - cannot process request", "ERROR")
+            return "", history, self.get_quote_files(), self.get_console_logs()
+
         try:
+            self.log_to_console("Starting conversation turn...")
+            self.log_to_console("Querying database and analyzing request...")
+            self.log_to_console(f"Thread ID: {self.thread_id}")
+            self.log_to_console(f"Processing message: {actual_message}")
+            
             # Run conversation turn
             response = run_conversation_turn(
                 compiled_graph=self.compiled_graph,
                 thread_id=self.thread_id,
-                user_input=message,
+                user_input=actual_message,
                 callback_manager=self.callback_manager
             )
             
-            # Add to history
-            history.append({"role": "user", "content": message})
-            history.append({"role": "assistant", "content": response})
+            self.log_to_console(f"Raw AI response: {response[:200]}...")
+            self.log_to_console("AI response generated successfully")
             
-            # Check if a new quote was generated by looking for "Quote generated" or similar in response
+            # Replace the loading message with actual response
+            if history and history[-1]["role"] == "assistant":
+                history[-1] = {"role": "assistant", "content": response}
+            
+            # Check if a new quote was generated
             if "quote" in response.lower() and ("generated" in response.lower() or "created" in response.lower()):
                 response += "\n\n📄 **Check the 'Generated Quotes' tab to view your quote file!**"
                 history[-1] = {"role": "assistant", "content": response}
+                self.log_to_console("Quote file generated and saved")
             
         except Exception as e:
             error_response = f"❌ Error processing your request: {str(e)}"
-            history.append({"role": "user", "content": message})
-            history.append({"role": "assistant", "content": error_response})
+            # Replace the loading message with error
+            if history and history[-1]["role"] == "assistant":
+                history[-1] = {"role": "assistant", "content": error_response}
+            
+            self.log_to_console(f"Error processing request: {str(e)}", "ERROR")
         
-        return "", history, self.get_quote_files()
-
-
+        # Clear the stored message after processing
+        self.current_message = ""
+        
+        return "", history, self.get_quote_files(), self.get_console_logs()
+    
+    def get_intermediate_logs(self) -> str:
+        """Get console logs for intermediate updates."""
+        return self.get_console_logs()
 def create_gradio_interface():
     """Create and configure the Gradio interface."""
     
@@ -155,6 +278,35 @@ def create_gradio_interface():
             padding: 20px !important;
             font-family: 'Inter', system-ui, -apple-system, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
         }
+        .console-logs {
+            background-color: #1a1a1a;
+            color: #00ff00;
+            font-family: 'Courier New', monospace;
+            padding: 15px;
+            border-radius: 8px;
+            height: 400px !important;
+            max-height: 500px !important;
+            overflow-y: auto !important;
+            font-size: 12px;
+            line-height: 1.5;
+            border: 1px solid #333;
+            white-space: pre-wrap;
+            word-wrap: break-word;
+        }
+        .console-logs::-webkit-scrollbar {
+            width: 8px;
+        }
+        .console-logs::-webkit-scrollbar-track {
+            background: #2a2a2a;
+            border-radius: 4px;
+        }
+        .console-logs::-webkit-scrollbar-thumb {
+            background: #555;
+            border-radius: 4px;
+        }
+        .console-logs::-webkit-scrollbar-thumb:hover {
+            background: #777;
+        }
         /* ensure main text elements inherit the font */
         .gradio-markdown, .gradio-chatbot, .gradio-textbox, .gradio-button, .gradio-accordion {
             font-family: inherit;
@@ -208,6 +360,28 @@ def create_gradio_interface():
                     )
                     send_btn = gr.Button("Send", variant="primary", scale=1)
                 
+                # Console logs section
+                with gr.Accordion("🔍 Console Logs & Processing Info", open=False):
+                    console_display = gr.Textbox(
+                        value=chat_assistant.get_console_logs(),
+                        label="Real-time Processing Logs",
+                        lines=20,
+                        max_lines=30,
+                        interactive=False,
+                        elem_classes=["console-logs"],
+                        show_copy_button=True,
+                        autoscroll=True
+                    )
+                    
+                    with gr.Row():
+                        refresh_logs_btn = gr.Button("🔄 Refresh Logs", variant="secondary", scale=1)
+                        clear_logs_btn = gr.Button("🗑️ Clear Logs", variant="secondary", scale=1)
+                        auto_refresh_checkbox = gr.Checkbox(
+                            label="Auto-refresh logs (every 2 seconds)",
+                            value=False,
+                            scale=1
+                        )
+                
                 # Example queries
                 with gr.Row():
                     gr.Examples(
@@ -283,8 +457,13 @@ def create_gradio_interface():
             )
         
         # Event handlers
-        def submit_message(message, history):
-            return chat_assistant.chat_function(message, history)
+        def submit_message_immediate(message, history):
+            """Immediately show user message and loading state."""
+            return chat_assistant.chat_function_immediate(message, history)
+        
+        def process_message_full(message, history):
+            """Process the full message after showing immediate feedback."""
+            return chat_assistant.chat_function_process(message, history)
         
         def refresh_files():
             files = chat_assistant.get_quote_files()
@@ -297,17 +476,40 @@ def create_gradio_interface():
                 return content
             return "Select a quote file to view its content."
         
-        # Wire up the events
+        def refresh_console_logs():
+            return chat_assistant.get_console_logs()
+        
+        def clear_console_logs():
+            chat_assistant.console_logs = []
+            chat_assistant.log_to_console("Console logs cleared")
+            return chat_assistant.get_console_logs()
+        
+        def auto_refresh_logs():
+            """Auto-refresh function for logs - returns updated logs"""
+            return chat_assistant.get_console_logs()
+        
+        # Set up auto-refresh timer
+        timer = gr.Timer(2)  # Refresh every 2 seconds
+        
+        # Wire up the events with better UX
         msg_input.submit(
-            submit_message,
+            submit_message_immediate,
+            inputs=[msg_input, chatbot],
+            outputs=[msg_input, chatbot, console_display]
+        ).then(
+            process_message_full,
             inputs=[msg_input, chatbot],
-            outputs=[msg_input, chatbot, quote_files_display]
+            outputs=[msg_input, chatbot, quote_files_display, console_display]
         )
         
         send_btn.click(
-            submit_message,
+            submit_message_immediate,
             inputs=[msg_input, chatbot],
-            outputs=[msg_input, chatbot, quote_files_display]
+            outputs=[msg_input, chatbot, console_display]
+        ).then(
+            process_message_full,
+            inputs=[msg_input, chatbot],
+            outputs=[msg_input, chatbot, quote_files_display, console_display]
         )
         
         refresh_btn.click(
@@ -320,6 +522,28 @@ def create_gradio_interface():
             inputs=[file_dropdown],
             outputs=[quote_content]
         )
+        
+        refresh_logs_btn.click(
+            refresh_console_logs,
+            outputs=[console_display]
+        )
+        
+        clear_logs_btn.click(
+            clear_console_logs,
+            outputs=[console_display]
+        )
+        
+        # Auto-refresh functionality
+        auto_refresh_checkbox.change(
+            lambda enabled: timer.start() if enabled else timer.stop(),
+            inputs=[auto_refresh_checkbox],
+            outputs=[]
+        )
+        
+        timer.tick(
+            auto_refresh_logs,
+            outputs=[console_display]
+        )
     
     return interface
 
@@ -336,7 +560,8 @@ def main():
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
-        show_error=True
+        show_error=True,
+        debug=True
     )