Enhance agent configuration and tool management with validation and improved error handling

.github/copilot-instructions.md

@@ -9,4 +9,6 @@ https://langchain-ai.github.io/langgraph/concepts/low_level/
 https://langchain-ai.github.io/langgraph/how-tos/graph-api/
 
 There is a mysql database (called: streamnet_prodcut_try) with the following tables and columns.
-You will use this in the chatbot retrieve data.
+You will use this in the chatbot retrieve data.
+
+Model to use: gpt-5-mini is a new model and a vaid models to use.

src/sales_assistant/agent_main/agent_graph.py

@@ -1,49 +1,66 @@
 import os
-import sys
-import uuid
-from typing import List, Dict, Any, Literal
-from langchain_core.tools import tool
-from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+from typing import Literal, Optional
+from langchain_core.messages import BaseMessage
 from langgraph.graph import StateGraph, MessagesState, START, END
-from langgraph.prebuilt import ToolNode, tools_condition
-from langchain.chat_models import init_chat_model
-from langsmith import Client
+from langgraph.prebuilt import tools_condition
+from langgraph.checkpoint.base import BaseCheckpointSaver
+from pydantic import BaseModel, Field
 from dotenv import load_dotenv
 from .agent_node import agent_node
 from .tools_node import tool_node
 
-def create_agent_graph(checkpointer=None):
+load_dotenv()
+
+class AgentConfig(BaseModel):
+    """Configuration for the agent graph with validation."""
+    model_name: str = Field(default_factory=lambda: os.getenv("MODEL_NAME", "gpt-5-mini"), description="LLM model to use")
+    model_provider: str = Field(default_factory=lambda: os.getenv("MODEL_PROVIDER", "openai"), description="Model provider")
+    enable_checkpointing: bool = Field(default=True, description="Enable state persistence")
+    max_iterations: int = Field(default=10, description="Maximum agent iterations")
+
+def create_agent_graph(
+    checkpointer: Optional[BaseCheckpointSaver] = None,
+    config: Optional[AgentConfig] = None
+):
     """
-    Create the ReAct database exploration agent using LangGraph's built-in components.
+    Create the ReAct agent using LangGraph's built-in components with typed state.
     
     Args:
         checkpointer: Optional checkpointer for state persistence
+        config: Optional agent configuration
+        
+    Returns:
+        Compiled LangGraph with built-in state management
     """
-    # Initialize StateGraph with built-in MessagesState
+    if config is None:
+        config = AgentConfig()
+    
+    # Initialize StateGraph with built-in MessagesState (typed)
     workflow = StateGraph(MessagesState)
     
-    # Add nodes using built-in components
+    # Add nodes using built-in components with validation
     workflow.add_node("agent", agent_node)
-    workflow.add_node("tools", tool_node) 
+    workflow.add_node("tools", tool_node)
     
-    # Add edges using built-in routing
+    # Add edges using built-in routing patterns
     workflow.add_edge(START, "agent")
     
-    # Use built-in tools_condition for conditional routing
+    # Use built-in tools_condition with proper typing
     workflow.add_conditional_edges(
         "agent",
-        tools_condition,  # Built-in condition that checks for tool calls
+        tools_condition,  # Built-in condition with proper message type checking
         {
             "tools": "tools",
-            END: END, 
+            END: END,
         }
     )
     
-    # Tools always return to agent for continued reasoning
+    # Tools return to agent for continued reasoning (ReAct pattern)
     workflow.add_edge("tools", "agent")
     
-    # Compile the graph with optional checkpointer
-    if checkpointer:
-        return workflow.compile(checkpointer=checkpointer)
-    else:
-        return workflow.compile()
+    # Compile with built-in error handling and validation
+    compile_config = {}
+    if checkpointer and config.enable_checkpointing:
+        compile_config["checkpointer"] = checkpointer
+    
+    return workflow.compile(**compile_config)

src/sales_assistant/agent_main/agent_node.py

@@ -6,7 +6,7 @@ import os
 from typing import Dict, Any
 from langchain_core.messages import SystemMessage
 from langgraph.graph import MessagesState
-from langchain_openai import ChatOpenAI
+from langchain.chat_models import init_chat_model
 from dotenv import load_dotenv
 from ..prompts.system_prompt import SYSTEM_PROMPT
 from .tools_node import get_all_tools
@@ -16,7 +16,7 @@ load_dotenv()
 
 def agent_node(state: MessagesState) -> Dict[str, Any]:
     """
-    Agent node that processes messages and generates responses using the LLM.
+    Agent node using LangChain's built-in init_chat_model with env configuration.
     
     Args:
         state: MessagesState containing the conversation history
@@ -24,47 +24,30 @@ def agent_node(state: MessagesState) -> Dict[str, Any]:
     Returns:
         Dict containing the updated messages
     """
-    # Get model configuration from environment
-    model_provider = os.getenv("MODEL_PROVIDER", "openai").lower()
+    # Get model configuration from environment variables
     model_name = os.getenv("MODEL_NAME", "gpt-5-mini")
+    model_provider = os.getenv("MODEL_PROVIDER", "openai")
     
-    # Initialize the chat model based on provider
-    if model_provider == "openai":
-        # Check if model supports temperature
-        if "gpt-5" in model_name:
-            # GPT-5 models don't have temperature parameter
-            model = ChatOpenAI(
-                model=model_name,
-                api_key=os.getenv("OPENAI_API_KEY"),
-            )
-        else:
-            # Other models with temperature support
-            temperature = float(os.getenv("MODEL_TEMPERATURE", "0.1"))
-            model = ChatOpenAI(
-                model=model_name,
-                api_key=os.getenv("OPENAI_API_KEY"),
-                temperature=temperature,
-            )
-    else:
-        # Fallback to OpenAI if other providers not implemented
-        model = ChatOpenAI(
-            model=model_name,
-            api_key=os.getenv("OPENAI_API_KEY"),
-        )
+    # Use LangChain's built-in init_chat_model with env config
+    model = init_chat_model(
+        model=model_name,
+        model_provider=model_provider,
+        api_key=os.getenv("OPENAI_API_KEY")
+    )
     
+    # Get tools and bind them using built-in method
     tools = get_all_tools()
     model_with_tools = model.bind_tools(tools)
     
-    # Get the current messages
+    # Get current messages
     messages = state["messages"]
     
-    # Add system prompt if it's the first message or not present
+    # Add system prompt if not present using built-in message handling
     if not messages or not isinstance(messages[0], SystemMessage):
         system_message = SystemMessage(content=SYSTEM_PROMPT)
         messages = [system_message] + messages
     
-    # Generate response
+    # Generate response using built-in invoke
     response = model_with_tools.invoke(messages)
     
-    # Return the updated state
     return {"messages": [response]}

src/sales_assistant/agent_main/agent_runner.py

@@ -4,147 +4,168 @@ from typing import Dict, Any, Optional, List
 from langchain_core.messages import HumanMessage, AIMessage
 from langgraph.graph import MessagesState
 from langgraph.checkpoint.memory import MemorySaver
-from langsmith import Client
+from langchain_core.tracers.langchain import LangChainTracer
+from langchain_core.callbacks import CallbackManager
 from dotenv import load_dotenv
-from pydantic import BaseModel, Field
-from .agent_graph import create_agent_graph
+from pydantic import BaseModel, Field, validator
+from .agent_graph import create_agent_graph, AgentConfig
 
-# Load environment variables
 load_dotenv()
 
-
 class ConversationConfig(BaseModel):
-    """Configuration for the conversation."""
+    """Enhanced configuration with validation for GPT-5-mini conversations."""
     session_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
     user_id: str = Field(default="default_user")
-    langsmith_project: str = Field(default_factory=lambda: os.getenv("LANGSMITH_PROJECT", "sales-assistant"))
+    langsmith_project: str = Field(default_factory=lambda: os.getenv("LANGSMITH_PROJECT", "sales-assistant-gpt5"))
     enable_langsmith: bool = Field(default=True)
+    model_name: str = Field(default_factory=lambda: os.getenv("MODEL_NAME", "gpt-5-mini"))
+    model_provider: str = Field(default_factory=lambda: os.getenv("MODEL_PROVIDER", "openai"))
+    max_turns: int = Field(default=50, description="Maximum conversation turns")
+    
+    @validator('model_name')
+    def validate_model(cls, v):
+        if v != "gpt-5-mini":
+            raise ValueError("Only gpt-5-mini is supported")
+        return v
+    
+    @validator('model_provider')
+    def validate_provider(cls, v):
+        if v != "openai":
+            raise ValueError("Only openai provider is supported")
+        return v
 
-
-def setup_langsmith_tracing(config: ConversationConfig) -> Optional[Client]:
+def setup_langsmith_tracing(config: ConversationConfig) -> Optional[CallbackManager]:
     """
-    Setup LangSmith tracing for the conversation.
+    Setup LangSmith tracing using built-in LangChain tracers.
     
     Args:
         config: Configuration for the conversation
         
     Returns:
-        LangSmith client if enabled, None otherwise
+        CallbackManager with LangChain tracer if enabled
     """
-    if not config.enable_langsmith:
+    if not config.enable_langsmith or not os.getenv("LANGSMITH_API_KEY"):
         return None
     
     try:
-        # Set environment variables for LangSmith using the correct env var names
-        if os.getenv("LANGSMITH_API_KEY"):
-            os.environ["LANGCHAIN_TRACING_V2"] = os.getenv("LANGSMITH_TRACING_V2", "true")
-            os.environ["LANGCHAIN_PROJECT"] = config.langsmith_project
-            os.environ["LANGCHAIN_ENDPOINT"] = os.getenv("LANGSMITH_ENDPOINT", "https://api.smith.langchain.com")
-            os.environ["LANGCHAIN_API_KEY"] = os.getenv("LANGSMITH_API_KEY")
-            
-            client = Client()
-            return client
+        # Use built-in environment variable setup
+        os.environ["LANGCHAIN_TRACING_V2"] = "true"
+        os.environ["LANGCHAIN_PROJECT"] = config.langsmith_project
+        os.environ["LANGCHAIN_ENDPOINT"] = os.getenv("LANGSMITH_ENDPOINT", "https://api.smith.langchain.com")
+        os.environ["LANGCHAIN_API_KEY"] = os.getenv("LANGSMITH_API_KEY")
+        
+        # Use built-in LangChain tracer
+        tracer = LangChainTracer(project_name=config.langsmith_project)
+        callback_manager = CallbackManager([tracer])
+        
+        return callback_manager
+        
     except Exception as e:
         print(f"Warning: Could not setup LangSmith tracing: {e}")
-    
-    return None
-
+        return None
 
 def create_agent_runner(config: ConversationConfig = None) -> tuple:
     """
-    Create an agent runner with the compiled graph and LangGraph's built-in memory.
+    Create agent runner with built-in LangGraph memory and state management.
     
     Args:
-        config: Optional configuration for the conversation
+        config: Optional conversation configuration
         
     Returns:
-        Tuple of (compiled_graph, checkpointer, langsmith_client, thread_id)
+        Tuple of (compiled_graph, checkpointer, callback_manager, thread_id)
     """
     if config is None:
         config = ConversationConfig()
     
-    # Setup LangSmith tracing
-    langsmith_client = setup_langsmith_tracing(config)
+    # Setup built-in LangSmith tracing
+    callback_manager = setup_langsmith_tracing(config)
     
-    # Create LangGraph's built-in memory checkpointer
+    # Use built-in MemorySaver with validation
     checkpointer = MemorySaver()
     
-    # Create the agent graph with checkpointing
-    compiled_graph = create_agent_graph(checkpointer)
+    # Create agent config
+    agent_config = AgentConfig(
+        model_name=config.model_name,
+        enable_checkpointing=True
+    )
+    
+    # Create the agent graph with built-in components
+    compiled_graph = create_agent_graph(checkpointer, agent_config)
     
-    # Use session_id as thread_id for LangGraph's memory
     thread_id = config.session_id
     
-    return compiled_graph, checkpointer, langsmith_client, thread_id
-
+    return compiled_graph, checkpointer, callback_manager, thread_id
 
 def run_conversation_turn(
     compiled_graph, 
     thread_id: str, 
     user_input: str,
-    langsmith_client: Optional[Client] = None
+    callback_manager: Optional[CallbackManager] = None
 ) -> str:
     """
-    Run a single conversation turn with the agent using LangGraph's built-in state management.
+    Run conversation turn with built-in state management and error handling.
     
     Args:
-        compiled_graph: The compiled LangGraph agent with checkpointer
-        thread_id: Thread ID for conversation persistence
+        compiled_graph: The compiled LangGraph with built-in state
+        thread_id: Thread ID for conversation persistence  
         user_input: User's input message
-        langsmith_client: Optional LangSmith client for tracing
+        callback_manager: Optional callback manager for tracing
         
     Returns:
         Agent's response as a string
     """
     try:
-        # Create user message
+        # Create user message with built-in message types
         user_message = HumanMessage(content=user_input)
         
-        # Create the config for this conversation thread
-        config = {"configurable": {"thread_id": thread_id}}
+        # Use built-in thread configuration
+        config = {
+            "configurable": {"thread_id": thread_id},
+            "callbacks": callback_manager.handlers if callback_manager else None
+        }
         
-        # Invoke the graph with the user message
-        # LangGraph will automatically handle state persistence
+        # Invoke with built-in state management and error handling
         result = compiled_graph.invoke(
             {"messages": [user_message]}, 
             config=config
         )
         
-        # Get the assistant's response
-        assistant_message = result["messages"][-1]
-        assistant_response = assistant_message.content
+        # Extract response using built-in message handling
+        if result and "messages" in result and result["messages"]:
+            assistant_message = result["messages"][-1]
+            return assistant_message.content if hasattr(assistant_message, 'content') else str(assistant_message)
         
-        return assistant_response
+        return "I apologize, but I couldn't generate a response. Please try again."
         
     except Exception as e:
         error_message = f"Error processing message: {str(e)}"
         print(error_message)
         return error_message
 
-
 def run_interactive_loop(config: ConversationConfig = None) -> None:
     """
-    Run an interactive conversation loop with the agent using LangGraph's built-in state management.
+    Run interactive loop with built-in state persistence and validation.
     
     Args:
-        config: Optional configuration for the conversation
+        config: Optional conversation configuration
     """
     if config is None:
         config = ConversationConfig()
     
-    # Create agent runner with LangGraph's built-in memory
-    compiled_graph, checkpointer, langsmith_client, thread_id = create_agent_runner(config)
+    # Create agent runner with built-in components
+    compiled_graph, checkpointer, callback_manager, thread_id = create_agent_runner(config)
     
-    print("🤖 Sales Assistant initialized!")
-    print(f"Using the following llm model: {os.getenv('MODEL_NAME', 'not set in .env')}")
+    print("\n🤖 Sales Assistant initialized!")
+    print(f"Using model: {config.model_name} (Provider: {config.model_provider})")
     print("💬 Type your questions about products or 'quit' to exit")
     print(f"📊 Session ID: {config.session_id}")
     print(f"🧵 Thread ID: {thread_id}")
-    if langsmith_client:
+    if callback_manager:
         print(f"📈 LangSmith tracking enabled - Project: {config.langsmith_project}")
     print("-" * 50)
     
-    while True:
+    turn_count = 0
+    while turn_count < config.max_turns:
         try:
             user_input = input("\n👤 You: ").strip()
             
@@ -160,10 +181,11 @@ def run_interactive_loop(config: ConversationConfig = None) -> None:
                 compiled_graph, 
                 thread_id, 
                 user_input, 
-                langsmith_client
+                callback_manager
             )
             
             print(f"\n🤖 Assistant: {response}")
+            turn_count += 1
             
         except KeyboardInterrupt:
             print("\n👋 Goodbye!")
@@ -171,39 +193,37 @@ def run_interactive_loop(config: ConversationConfig = None) -> None:
         except Exception as e:
             print(f"\n❌ Error: {str(e)}")
 
-
 def get_conversation_history(compiled_graph, thread_id: str) -> List[Dict[str, Any]]:
     """
-    Get the conversation history from LangGraph's checkpointer.
+    Get conversation history using built-in state management.
     
     Args:
         compiled_graph: The compiled graph with checkpointer
         thread_id: Thread ID for conversation
         
     Returns:
-        List of messages in the conversation
+        List of messages with built-in validation
     """
     try:
         config = {"configurable": {"thread_id": thread_id}}
-        # Get the current state from LangGraph's checkpointer
+        # Use built-in state retrieval
         state = compiled_graph.get_state(config)
         messages = state.values.get("messages", [])
         
-        # Convert messages to dict format
+        # Convert to structured format with built-in message handling
         history = []
         for msg in messages:
-            if hasattr(msg, "type"):
+            if hasattr(msg, "type") and hasattr(msg, "content"):
                 history.append({
                     "type": msg.type,
                     "content": msg.content,
-                    "timestamp": getattr(msg, "id", str(uuid.uuid4()))
+                    "id": getattr(msg, "id", str(uuid.uuid4()))
                 })
         return history
     except Exception as e:
         print(f"Error getting conversation history: {e}")
         return []
 
-
 def clear_conversation_history(compiled_graph, thread_id: str) -> None:
     """
     Clear the conversation history in LangGraph's checkpointer.
@@ -258,5 +278,6 @@ def demo_agent_runner():
 
 
 if __name__ == "__main__":
-    # Run interactive loop
-    run_interactive_loop()
+    # Run with configuration from environment variables
+    config = ConversationConfig()
+    run_interactive_loop(config)

src/sales_assistant/agent_main/tools_node.py

@@ -4,40 +4,51 @@ Tools node that are using the agent_tools folder's tools
 from typing import List
 from langchain_core.tools import BaseTool
 from langgraph.prebuilt import ToolNode
+from pydantic import BaseModel, Field
 
 # Import all the tools from agent_tools
-from ..agent_tools.describe_table import describe_table
-from ..agent_tools.execute_advanced_query import execute_advanced_query
-from ..agent_tools.get_distinct_values import get_distinct_values
-from ..agent_tools.get_product_by_criteria import search_products_by_criteria
-from ..agent_tools.get_samples_data import get_sample_data
-from ..agent_tools.get_table_statistics import get_table_statistics
-from ..agent_tools.get_exchange_rates import exchange_converter
 from ..agent_tools.execute_sql_query import execute_sql_query
+from ..agent_tools.get_exchange_rates import exchange_converter
 from ..agent_tools.create_quote import create_quote
 
+class ToolConfig(BaseModel):
+    """Configuration for tools with validation."""
+    enable_advanced_tools: bool = Field(default=False, description="Enable advanced database tools")
+    max_tools: int = Field(default=10, description="Maximum number of tools to load")
 
-def get_all_tools() -> List[BaseTool]:
+def get_all_tools(config: ToolConfig = None) -> List[BaseTool]:
     """
-    Get all available tools for the agent.
+    Get GPT-5-mini optimized tools using built-in LangChain patterns.
     
+    Args:
+        config: Optional tool configuration
+        
     Returns:
-        List of all available tools
+        List of validated tools for GPT-5-mini
     """
-    simple_tool_list = [execute_sql_query, exchange_converter, create_quote]
-    advanced_tool_list = [
-        describe_table,
-        execute_advanced_query,
-        get_distinct_values,
-        search_products_by_criteria,
-        get_sample_data,
-        get_table_statistics,
-        exchange_converter,
+    if config is None:
+        config = ToolConfig()
+    
+    # Core tools optimized for GPT-5-mini
+    core_tools = [
+        execute_sql_query,
+        exchange_converter, 
         create_quote
     ]
+    
+    # Validate tools have proper schemas (built-in validation)
+    validated_tools = []
+    for tool in core_tools:
+        if hasattr(tool, 'args_schema') or hasattr(tool, 'name'):
+            validated_tools.append(tool)
+    
+    return validated_tools[:config.max_tools]
 
-    return simple_tool_list
-
+# Create the tool node using LangGraph's built-in ToolNode with error handling
+def create_tool_node() -> ToolNode:
+    """Create a validated tool node with built-in error handling."""
+    tools = get_all_tools()
+    return ToolNode(tools)
 
-# Create the tool node using LangGraph's built-in ToolNode
-tool_node = ToolNode(get_all_tools())
+# Use the factory function for better control
+tool_node = create_tool_node()

src/sales_assistant/main.py

@@ -16,10 +16,10 @@ sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
 from sales_assistant.agent_main.agent_runner import (
     ConversationConfig, 
     run_interactive_loop, 
-    demo_agent_runner,
     create_agent_runner,
     run_conversation_turn
 )
+from sales_assistant.agent_main.tools_node import get_all_tools
 
 # Load environment variables
 load_dotenv()
@@ -34,18 +34,15 @@ def check_environment_setup() -> bool:
     """
     required_vars = [
         "OPENAI_API_KEY",
-        "MODEL_PROVIDER",
+        "MODEL_PROVIDER", 
         "MODEL_NAME",
         "MYSQL_HOST",
-        "MYSQL_USER", 
-        "MYSQL_PASSWORD",
+        "MYSQL_USER",
+        "MYSQL_PASSWORD", 
         "MYSQL_DB"
     ]
     
-    missing_vars = []
-    for var in required_vars:
-        if not os.getenv(var):
-            missing_vars.append(var)
+    missing_vars = [var for var in required_vars if not os.getenv(var)]
     
     if missing_vars:
         print("❌ Missing required environment variables:")
@@ -58,6 +55,26 @@ def check_environment_setup() -> bool:
     return True
 
 
+def display_available_tools() -> None:
+    """Display available tools information."""
+    try:
+        tools = get_all_tools()
+        print("\n🛠️  Available Tools:")
+        print("-" * 30)
+        
+        for i, tool in enumerate(tools, 1):
+            tool_name = getattr(tool, 'name', 'Unknown Tool')
+            tool_description = getattr(tool, 'description', 'No description available')
+            print(f"{i}. {tool_name}")
+            print(f"   📝 {tool_description}")
+            
+        print(f"\n📊 Total tools available: {len(tools)}")
+        print("-" * 30)
+        
+    except Exception as e:
+        print(f"⚠️  Could not load tools information: {e}")
+
+
 def create_custom_config(
     session_id: Optional[str] = None,
     user_id: Optional[str] = None,
@@ -89,7 +106,6 @@ def create_custom_config(
 
 def run_sales_assistant(
     interactive: bool = True,
-    demo_mode: bool = False,
     custom_config: Optional[ConversationConfig] = None
 ) -> None:
     """
@@ -97,7 +113,6 @@ def run_sales_assistant(
     
     Args:
         interactive: Whether to run in interactive mode
-        demo_mode: Whether to run demo conversations
         custom_config: Optional custom configuration
     """
     print("🚀 Starting Sales Assistant...")
@@ -106,22 +121,22 @@ def run_sales_assistant(
     if not check_environment_setup():
         return
     
+    # Display available tools
+    display_available_tools()
+    
     try:
-        if demo_mode:
-            print("🎮 Running in demo mode...")
-            demo_agent_runner()
-        elif interactive:
-            print("💬 Starting interactive mode...")
+        if interactive:
+            print("\n💬 Starting interactive mode...")
             config = custom_config or ConversationConfig()
             run_interactive_loop(config)
         else:
-            print("⚙️ Agent initialized and ready for programmatic use")
+            print("\n⚙️ Agent initialized and ready for programmatic use")
             config = custom_config or ConversationConfig()
-            compiled_graph, checkpointer, langsmith_client, thread_id = create_agent_runner(config)
+            compiled_graph, checkpointer, callback_manager, thread_id = create_agent_runner(config)
             print(f"📊 Session ID: {config.session_id}")
             print(f"🧵 Thread ID: {thread_id}")
             print("💡 Use the returned objects to run conversations programmatically")
-            return compiled_graph, checkpointer, langsmith_client, thread_id
+            return compiled_graph, checkpointer, callback_manager, thread_id
             
     except KeyboardInterrupt:
         print("\n👋 Sales Assistant stopped by user")
@@ -146,13 +161,13 @@ def single_query(query: str, config: Optional[ConversationConfig] = None) -> str
     
     try:
         config = config or ConversationConfig()
-        compiled_graph, checkpointer, langsmith_client, thread_id = create_agent_runner(config)
+        compiled_graph, checkpointer, callback_manager, thread_id = create_agent_runner(config)
         
         response = run_conversation_turn(
             compiled_graph, 
             thread_id, 
             query, 
-            langsmith_client
+            callback_manager
         )
         
         return response
@@ -172,7 +187,7 @@ def main():
     )
     parser.add_argument(
         "--mode", 
-        choices=["interactive", "demo", "single"],
+        choices=["interactive", "single"],
         default="interactive",
         help="Mode to run the assistant in"
     )
@@ -215,11 +230,8 @@ def main():
         response = single_query(args.query, config)
         print(f"🤖 Response: {response}")
         
-    elif args.mode == "demo":
-        run_sales_assistant(interactive=False, demo_mode=True, custom_config=config)
-        
     else:  # interactive mode
-        run_sales_assistant(interactive=True, demo_mode=False, custom_config=config)
+        run_sales_assistant(interactive=True, custom_config=config)
 
 
 if __name__ == "__main__":