Release v3.0.4

docker/Dockerfile.chat

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=3.0.2" \
+    "praisonai>=3.0.4" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 

docker/Dockerfile.dev

@@ -20,7 +20,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=3.0.2" \
+    "praisonai>=3.0.4" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

docker/Dockerfile.ui

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=3.0.2" \
+    "praisonai>=3.0.4" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

examples/python/session/session_persistence_example.py

@@ -0,0 +1,165 @@
+"""
+Session Persistence Example
+
+Demonstrates automatic session persistence with zero configuration.
+When you provide a session_id to an Agent, conversation history is
+automatically saved to disk and restored on subsequent runs.
+
+Usage:
+    python session_persistence_example.py
+
+Requirements:
+    - praisonaiagents package installed
+    - OPENAI_API_KEY environment variable set
+"""
+
+from praisonaiagents import Agent
+
+
+def example_basic_persistence():
+    """Basic session persistence example."""
+    print("=" * 60)
+    print("EXAMPLE 1: Basic Session Persistence")
+    print("=" * 60)
+    
+    session_id = "demo-session-basic"
+    
+    # Create agent with session_id
+    agent = Agent(
+        name="Assistant",
+        instructions="You are a helpful assistant. Be very brief.",
+        session_id=session_id,
+        verbose=False,
+    )
+    
+    # First message
+    print("\n[User]: My favorite color is blue and my lucky number is 7.")
+    response1 = agent.chat("My favorite color is blue and my lucky number is 7.")
+    print(f"[Assistant]: {response1}")
+    
+    # Second message - agent remembers
+    print("\n[User]: What is my favorite color?")
+    response2 = agent.chat("What is my favorite color?")
+    print(f"[Assistant]: {response2}")
+    
+    print(f"\n✅ Session saved to: ~/.praison/sessions/{session_id}.json")
+    print(f"   Chat history length: {len(agent.chat_history)} messages")
+
+
+def example_session_restoration():
+    """Demonstrates session restoration across Agent instances."""
+    print("\n" + "=" * 60)
+    print("EXAMPLE 2: Session Restoration")
+    print("=" * 60)
+    
+    session_id = "demo-session-restore"
+    
+    # First agent instance
+    print("\n--- First Agent Instance ---")
+    agent1 = Agent(
+        name="MemoryBot",
+        instructions="You are a helpful assistant. Be very brief.",
+        session_id=session_id,
+        verbose=False,
+    )
+    
+    print("[User]: Remember that my pet's name is Max.")
+    response1 = agent1.chat("Remember that my pet's name is Max.")
+    print(f"[Assistant]: {response1}")
+    
+    # Simulate new process by creating new agent instance
+    print("\n--- New Agent Instance (simulating restart) ---")
+    agent2 = Agent(
+        name="MemoryBot",
+        instructions="You are a helpful assistant. Be very brief.",
+        session_id=session_id,
+        verbose=False,
+    )
+    
+    print("[User]: What is my pet's name?")
+    response2 = agent2.chat("What is my pet's name?")
+    print(f"[Assistant]: {response2}")
+    
+    if "max" in response2.lower():
+        print("\n✅ Session restored successfully! Agent remembered 'Max'.")
+    else:
+        print("\n⚠️ Agent may not have remembered correctly.")
+
+
+def example_in_memory_only():
+    """Demonstrates in-memory memory without persistence."""
+    print("\n" + "=" * 60)
+    print("EXAMPLE 3: In-Memory Only (No session_id)")
+    print("=" * 60)
+    
+    # Agent without session_id - in-memory only
+    agent = Agent(
+        name="TempBot",
+        instructions="You are a helpful assistant. Be very brief.",
+        verbose=False,
+    )
+    
+    print("\n[User]: My name is Alice.")
+    response1 = agent.chat("My name is Alice.")
+    print(f"[Assistant]: {response1}")
+    
+    print("\n[User]: What is my name?")
+    response2 = agent.chat("What is my name?")
+    print(f"[Assistant]: {response2}")
+    
+    print(f"\n✅ In-memory chat history: {len(agent.chat_history)} messages")
+    print("   (This will be lost when the Agent instance is garbage collected)")
+
+
+def example_direct_store_access():
+    """Demonstrates direct access to the session store."""
+    print("\n" + "=" * 60)
+    print("EXAMPLE 4: Direct Session Store Access")
+    print("=" * 60)
+    
+    from praisonaiagents.session import get_default_session_store
+    
+    store = get_default_session_store()
+    session_id = "demo-direct-access"
+    
+    # Add messages directly
+    store.add_user_message(session_id, "Hello from direct access!")
+    store.add_assistant_message(session_id, "Hi! I received your message.")
+    
+    # Get history
+    history = store.get_chat_history(session_id)
+    print(f"\n✅ Added {len(history)} messages directly to session store")
+    
+    for msg in history:
+        print(f"   [{msg['role']}]: {msg['content']}")
+    
+    # List all sessions
+    sessions = store.list_sessions()
+    print(f"\n📋 Total sessions in store: {len(sessions)}")
+    
+    # Clean up demo session
+    store.delete_session(session_id)
+    print(f"   Deleted demo session: {session_id}")
+
+
+def main():
+    """Run all examples."""
+    print("\n" + "=" * 60)
+    print("SESSION PERSISTENCE EXAMPLES")
+    print("=" * 60)
+    
+    # Run examples
+    example_basic_persistence()
+    example_session_restoration()
+    example_in_memory_only()
+    example_direct_store_access()
+    
+    print("\n" + "=" * 60)
+    print("ALL EXAMPLES COMPLETE")
+    print("=" * 60)
+    print("\nSession files are stored in: ~/.praison/sessions/")
+    print("You can inspect them with: cat ~/.praison/sessions/<session_id>.json")
+
+
+if __name__ == "__main__":
+    main()

src/praisonai-agents/praisonaiagents/agent/agent.py

@@ -687,6 +687,11 @@ Your Goal: {self.goal}
         self._db = db
         self._session_id = session_id
         self._db_initialized = False
+        
+        # Session store for JSON-based persistence (lazy - no imports until used)
+        # Used when session_id is provided but no DB adapter
+        self._session_store = None
+        self._session_store_initialized = False
 
     @property
     def console(self):
@@ -2094,6 +2099,49 @@ Your Goal: {self.goal}"""
         
         self._db_initialized = True
         self._current_run_id = None  # Track current run
+    
+    def _init_session_store(self):
+        """
+        Initialize session store for JSON-based persistence (lazy, first chat only).
+        
+        This is used when session_id is provided but no DB adapter.
+        Enables automatic session persistence with zero configuration.
+        """
+        if self._session_store_initialized:
+            return
+        
+        # Only initialize if session_id is provided and no DB adapter
+        if self._session_id is None or self._db is not None:
+            self._session_store_initialized = True
+            return
+        
+        try:
+            from ..session import get_default_session_store
+            self._session_store = get_default_session_store()
+            
+            # Restore chat history from previous session
+            history = self._session_store.get_chat_history(self._session_id)
+            if history:
+                # Only restore if chat_history is empty (avoid duplicates)
+                if not self.chat_history:
+                    for msg in history:
+                        self.chat_history.append({
+                            "role": msg["role"],
+                            "content": msg["content"]
+                        })
+                    logging.info(f"Restored session {self._session_id} with {len(history)} messages from JSON store")
+            
+            # Set agent info
+            self._session_store.set_agent_info(
+                self._session_id,
+                agent_name=self.name,
+                user_id=self.user_id,
+            )
+        except Exception as e:
+            logging.warning(f"Failed to initialize session store: {e}")
+            self._session_store = None
+        
+        self._session_store_initialized = True
 
     def _start_run(self, input_content: str):
         """Start a new run (turn) for persistence tracking."""
@@ -2135,17 +2183,27 @@ Your Goal: {self.goal}"""
         self._current_run_id = None
 
     def _persist_message(self, role: str, content: str):
-        """Persist a message to the DB if adapter is provided."""
-        if self._db is None:
+        """Persist a message to the DB or session store."""
+        # Try DB adapter first
+        if self._db is not None:
+            try:
+                if role == "user":
+                    self._db.on_user_message(self._session_id, content)
+                elif role == "assistant":
+                    self._db.on_agent_message(self._session_id, content)
+            except Exception as e:
+                logging.warning(f"Failed to persist message to DB: {e}")
             return
         
-        try:
-            if role == "user":
-                self._db.on_user_message(self._session_id, content)
-            elif role == "assistant":
-                self._db.on_agent_message(self._session_id, content)
-        except Exception as e:
-            logging.warning(f"Failed to persist message: {e}")
+        # Fall back to session store (JSON-based)
+        if self._session_store is not None and self._session_id is not None:
+            try:
+                if role == "user":
+                    self._session_store.add_user_message(self._session_id, content)
+                elif role == "assistant":
+                    self._session_store.add_assistant_message(self._session_id, content)
+            except Exception as e:
+                logging.warning(f"Failed to persist message to session store: {e}")
 
     @property
     def session_id(self) -> Optional[str]:
@@ -2160,6 +2218,10 @@ Your Goal: {self.goal}"""
         # Initialize DB session on first chat (lazy)
         self._init_db_session()
         
+        # Initialize session store for JSON-based persistence (lazy)
+        # This enables automatic session persistence when session_id is provided
+        self._init_session_store()
+        
         # Start a new run for this chat turn
         prompt_str = prompt if isinstance(prompt, str) else str(prompt)
         self._start_run(prompt_str)

src/praisonai-agents/praisonaiagents/llm/llm.py

@@ -58,6 +58,12 @@ class LLM:
     # Class-level flag for one-time logging configuration
     _logging_configured = False
     
+    # Class-level cache for LiteLLM module (avoids repeated import overhead)
+    _litellm_module = None
+    
+    # Class-level flag for LiteLLM global settings (set once)
+    _litellm_configured = False
+    
     # Default window sizes for different models (75% of actual to be safe)
     MODEL_WINDOWS = {
         # OpenAI
@@ -272,14 +278,16 @@ Respond with ONLY a valid JSON tool call in this format:
         if not LLM._logging_configured:
             LLM._configure_logging()
             
-        # Import litellm after logging is configured
-        try:
-            import litellm
-        except ImportError:
-            raise ImportError(
-                "LiteLLM is required but not installed. "
-                "Please install with: pip install 'praisonaiagents[llm]'"
-            )
+        # Use cached LiteLLM module or import once (avoids repeated import overhead)
+        if LLM._litellm_module is None:
+            try:
+                import litellm
+                LLM._litellm_module = litellm
+            except ImportError:
+                raise ImportError(
+                    "LiteLLM is required but not installed. "
+                    "Please install with: pip install 'praisonaiagents[llm]'"
+                )
 
         self.model = model
         self.timeout = timeout
@@ -341,11 +349,12 @@ Respond with ONLY a valid JSON tool call in this format:
         self._formatted_tools_cache = {}
         self._max_cache_size = 100
         
-        # Enable error dropping for cleaner output
-        import litellm
-        litellm.drop_params = True
-        # Enable parameter modification for providers like Anthropic
-        litellm.modify_params = True
+        # Configure LiteLLM global settings only once (avoids repeated setup cost)
+        if not LLM._litellm_configured:
+            litellm = LLM._litellm_module
+            litellm.drop_params = True
+            litellm.modify_params = True
+            LLM._litellm_configured = True
         self._setup_event_tracking(events)
         
         # Log all initialization parameters when in debug mode or verbose >= 10

src/praisonai-agents/praisonaiagents/session/README.md

@@ -0,0 +1,185 @@
+# Session Persistence for PraisonAI Agents
+
+This module provides automatic session persistence with zero configuration.
+
+## Quick Start
+
+```python
+from praisonaiagents import Agent
+
+# With session persistence (auto-enabled)
+agent = Agent(
+    name="Assistant",
+    session_id="my-session-123"
+)
+agent.start("Hello, my name is Alice")
+
+# Later, in a new process - history is restored automatically
+agent = Agent(
+    name="Assistant", 
+    session_id="my-session-123"
+)
+agent.start("What is my name?")  # Agent remembers: "Alice"
+```
+
+## How It Works
+
+When you provide a `session_id` to an Agent:
+
+1. **Automatic Persistence**: Conversation history is automatically saved to disk
+2. **Automatic Restoration**: When a new Agent is created with the same `session_id`, history is restored
+3. **Zero Configuration**: No database setup required - uses JSON files by default
+
+### Default Storage Location
+
+Sessions are stored in: `~/.praison/sessions/{session_id}.json`
+
+### Session File Format
+
+```json
+{
+  "session_id": "my-session-123",
+  "messages": [
+    {"role": "user", "content": "Hello", "timestamp": 1704153600.0},
+    {"role": "assistant", "content": "Hi there!", "timestamp": 1704153601.5}
+  ],
+  "created_at": "2026-01-02T04:00:00+00:00",
+  "updated_at": "2026-01-02T04:01:00+00:00",
+  "agent_name": "Assistant"
+}
+```
+
+## Behavior Matrix
+
+| Scenario | Behavior |
+|----------|----------|
+| `session_id` provided, no DB | JSON persistence (auto) |
+| `session_id` provided, with DB | DB adapter used |
+| No `session_id`, same Agent instance | In-memory only |
+| No `session_id`, new Agent instance | No history |
+
+## Advanced Usage
+
+### Direct Session Store Access
+
+```python
+from praisonaiagents.session import get_default_session_store
+
+store = get_default_session_store()
+
+# Add messages
+store.add_user_message("session-123", "Hello")
+store.add_assistant_message("session-123", "Hi there!")
+
+# Get history
+history = store.get_chat_history("session-123")
+# [{"role": "user", "content": "Hello"}, {"role": "assistant", "content": "Hi there!"}]
+
+# List all sessions
+sessions = store.list_sessions()
+
+# Delete a session
+store.delete_session("session-123")
+```
+
+### Custom Session Directory
+
+```python
+from praisonaiagents.session import DefaultSessionStore
+
+store = DefaultSessionStore(
+    session_dir="/custom/path/sessions",
+    max_messages=200,  # Default: 100
+    lock_timeout=10.0,  # Default: 5.0 seconds
+)
+```
+
+### Using with DB Adapter
+
+When a DB adapter is provided, it takes precedence over JSON persistence:
+
+```python
+from praisonaiagents import Agent
+from praisonai.db import PostgresAdapter
+
+agent = Agent(
+    name="Assistant",
+    session_id="my-session",
+    db=PostgresAdapter(connection_string="...")
+)
+```
+
+## Multi-Process Safety
+
+The session store uses file locking to ensure safe concurrent access:
+
+- **Unix**: Uses `fcntl.flock()` for file locking
+- **Windows**: Uses `msvcrt.locking()` for file locking
+- **Atomic Writes**: Uses temp file + rename to prevent corruption
+
+Multiple processes can safely read/write to the same session.
+
+## Context Caching
+
+For cost optimization, use `prompt_caching=True` with Anthropic models:
+
+```python
+agent = Agent(
+    name="Assistant",
+    session_id="my-session",
+    prompt_caching=True,  # Enables Anthropic prompt caching
+)
+```
+
+This caches the system prompt, reducing token costs for repeated conversations.
+
+## API Reference
+
+### DefaultSessionStore
+
+```python
+class DefaultSessionStore:
+    def __init__(
+        self,
+        session_dir: Optional[str] = None,  # Default: ~/.praison/sessions/
+        max_messages: int = 100,
+        lock_timeout: float = 5.0,
+    ): ...
+    
+    def add_message(self, session_id: str, role: str, content: str) -> bool: ...
+    def add_user_message(self, session_id: str, content: str) -> bool: ...
+    def add_assistant_message(self, session_id: str, content: str) -> bool: ...
+    def get_chat_history(self, session_id: str, max_messages: int = None) -> List[Dict]: ...
+    def get_session(self, session_id: str) -> SessionData: ...
+    def clear_session(self, session_id: str) -> bool: ...
+    def delete_session(self, session_id: str) -> bool: ...
+    def list_sessions(self, limit: int = 50) -> List[Dict]: ...
+    def session_exists(self, session_id: str) -> bool: ...
+```
+
+### SessionData
+
+```python
+@dataclass
+class SessionData:
+    session_id: str
+    messages: List[SessionMessage]
+    created_at: str
+    updated_at: str
+    agent_name: Optional[str]
+    user_id: Optional[str]
+    metadata: Dict[str, Any]
+    
+    def get_chat_history(self, max_messages: int = None) -> List[Dict[str, str]]: ...
+```
+
+### SessionMessage
+
+```python
+@dataclass
+class SessionMessage:
+    role: str  # "user", "assistant", "system"
+    content: str
+    timestamp: float
+    metadata: Dict[str, Any]
+```

src/praisonai-agents/praisonaiagents/session/__init__.py

@@ -0,0 +1,70 @@
+"""
+Session persistence module for PraisonAI Agents.
+
+Provides automatic session persistence with zero configuration.
+When a session_id is provided to an Agent, conversation history
+is automatically persisted to disk and restored on subsequent runs.
+
+Usage:
+    from praisonaiagents import Agent
+    
+    # With session persistence (auto-enabled)
+    agent = Agent(
+        name="Assistant",
+        session_id="my-session-123"
+    )
+    agent.start("Hello")
+    
+    # Later, new process - history is restored
+    agent = Agent(
+        name="Assistant", 
+        session_id="my-session-123"
+    )
+    agent.start("What did I say before?")  # Remembers!
+
+Default storage: ~/.praison/sessions/{session_id}.json
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .store import DefaultSessionStore, SessionMessage, SessionData
+
+# Lazy loading for zero import overhead
+_module_cache = {}
+
+
+def __getattr__(name: str):
+    """Lazy load session components."""
+    if name in _module_cache:
+        return _module_cache[name]
+    
+    if name == "DefaultSessionStore":
+        from .store import DefaultSessionStore
+        _module_cache[name] = DefaultSessionStore
+        return DefaultSessionStore
+    
+    if name == "SessionMessage":
+        from .store import SessionMessage
+        _module_cache[name] = SessionMessage
+        return SessionMessage
+    
+    if name == "SessionData":
+        from .store import SessionData
+        _module_cache[name] = SessionData
+        return SessionData
+    
+    if name == "get_default_session_store":
+        from .store import get_default_session_store
+        _module_cache[name] = get_default_session_store
+        return get_default_session_store
+    
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    "DefaultSessionStore",
+    "SessionMessage", 
+    "SessionData",
+    "get_default_session_store",
+]

src/praisonai-agents/praisonaiagents/session/store.py

@@ -0,0 +1,521 @@
+"""
+Default Session Store for PraisonAI Agents.
+
+JSON-based session persistence with file locking and atomic writes.
+Zero dependencies beyond stdlib.
+"""
+
+import fcntl
+import json
+import logging
+import os
+import sys
+import tempfile
+import threading
+import time
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+# Default session directory
+DEFAULT_SESSION_DIR = os.path.expanduser("~/.praison/sessions")
+
+# Default limits
+DEFAULT_MAX_MESSAGES = 100
+DEFAULT_LOCK_TIMEOUT = 5.0  # seconds
+
+
+@dataclass
+class SessionMessage:
+    """A single message in a session."""
+    role: str  # "user", "assistant", "system"
+    content: str
+    timestamp: float = field(default_factory=time.time)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "role": self.role,
+            "content": self.content,
+            "timestamp": self.timestamp,
+            "metadata": self.metadata,
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SessionMessage":
+        """Create from dictionary."""
+        return cls(
+            role=data.get("role", "user"),
+            content=data.get("content", ""),
+            timestamp=data.get("timestamp", time.time()),
+            metadata=data.get("metadata", {}),
+        )
+
+
+@dataclass
+class SessionData:
+    """Complete session data structure."""
+    session_id: str
+    messages: List[SessionMessage] = field(default_factory=list)
+    created_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    updated_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    agent_name: Optional[str] = None
+    user_id: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "session_id": self.session_id,
+            "messages": [m.to_dict() for m in self.messages],
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "agent_name": self.agent_name,
+            "user_id": self.user_id,
+            "metadata": self.metadata,
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SessionData":
+        """Create from dictionary."""
+        messages = [
+            SessionMessage.from_dict(m) 
+            for m in data.get("messages", [])
+        ]
+        return cls(
+            session_id=data.get("session_id", ""),
+            messages=messages,
+            created_at=data.get("created_at", datetime.now(timezone.utc).isoformat()),
+            updated_at=data.get("updated_at", datetime.now(timezone.utc).isoformat()),
+            agent_name=data.get("agent_name"),
+            user_id=data.get("user_id"),
+            metadata=data.get("metadata", {}),
+        )
+    
+    def get_chat_history(self, max_messages: Optional[int] = None) -> List[Dict[str, str]]:
+        """
+        Get chat history in LLM-compatible format.
+        
+        Returns list of {"role": "user/assistant", "content": "..."} dicts.
+        """
+        messages = self.messages
+        if max_messages and len(messages) > max_messages:
+            messages = messages[-max_messages:]
+        return [{"role": m.role, "content": m.content} for m in messages]
+
+
+class FileLock:
+    """
+    Cross-platform file locking.
+    
+    Uses fcntl on Unix and msvcrt on Windows.
+    """
+    
+    def __init__(self, filepath: str, timeout: float = DEFAULT_LOCK_TIMEOUT):
+        self.filepath = filepath
+        self.timeout = timeout
+        self._lock_file = None
+        self._lock_path = filepath + ".lock"
+    
+    def __enter__(self):
+        self.acquire()
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.release()
+        return False
+    
+    def acquire(self) -> bool:
+        """Acquire the file lock."""
+        # Ensure directory exists
+        os.makedirs(os.path.dirname(self._lock_path) or ".", exist_ok=True)
+        
+        start_time = time.time()
+        while True:
+            try:
+                self._lock_file = open(self._lock_path, "w")
+                if sys.platform == "win32":
+                    # Windows locking
+                    import msvcrt
+                    msvcrt.locking(self._lock_file.fileno(), msvcrt.LK_NBLCK, 1)
+                else:
+                    # Unix locking
+                    fcntl.flock(self._lock_file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+                return True
+            except (IOError, OSError, BlockingIOError):
+                if self._lock_file:
+                    self._lock_file.close()
+                    self._lock_file = None
+                
+                if time.time() - start_time > self.timeout:
+                    logger.warning(f"Failed to acquire lock for {self.filepath} after {self.timeout}s")
+                    return False
+                
+                time.sleep(0.05)  # Wait 50ms before retry
+    
+    def release(self) -> None:
+        """Release the file lock."""
+        if self._lock_file:
+            try:
+                if sys.platform == "win32":
+                    import msvcrt
+                    msvcrt.locking(self._lock_file.fileno(), msvcrt.LK_UNLCK, 1)
+                else:
+                    fcntl.flock(self._lock_file.fileno(), fcntl.LOCK_UN)
+            except (IOError, OSError):
+                pass
+            finally:
+                self._lock_file.close()
+                self._lock_file = None
+                # Clean up lock file
+                try:
+                    os.remove(self._lock_path)
+                except (IOError, OSError):
+                    pass
+
+
+class DefaultSessionStore:
+    """
+    JSON-based session persistence with file locking.
+    
+    Features:
+    - Zero configuration required
+    - Automatic file locking for multi-process safety
+    - Atomic writes to prevent corruption
+    - Configurable message limits
+    - Thread-safe operations
+    
+    Usage:
+        store = DefaultSessionStore()
+        
+        # Add messages
+        store.add_message("session-123", "user", "Hello")
+        store.add_message("session-123", "assistant", "Hi there!")
+        
+        # Get history
+        history = store.get_chat_history("session-123")
+        # [{"role": "user", "content": "Hello"}, {"role": "assistant", "content": "Hi there!"}]
+        
+        # Restore in new process
+        store2 = DefaultSessionStore()
+        history = store2.get_chat_history("session-123")  # Same history!
+    """
+    
+    def __init__(
+        self,
+        session_dir: Optional[str] = None,
+        max_messages: int = DEFAULT_MAX_MESSAGES,
+        lock_timeout: float = DEFAULT_LOCK_TIMEOUT,
+    ):
+        """
+        Initialize session store.
+        
+        Args:
+            session_dir: Directory for session files. Defaults to ~/.praison/sessions/
+            max_messages: Maximum messages to keep per session.
+            lock_timeout: Timeout for file lock acquisition.
+        """
+        self.session_dir = session_dir or DEFAULT_SESSION_DIR
+        self.max_messages = max_messages
+        self.lock_timeout = lock_timeout
+        self._lock = threading.RLock()
+        self._cache: Dict[str, SessionData] = {}
+        
+        # Ensure session directory exists
+        os.makedirs(self.session_dir, exist_ok=True)
+    
+    def _get_session_path(self, session_id: str) -> str:
+        """Get the file path for a session."""
+        # Sanitize session_id for filesystem
+        safe_id = "".join(c if c.isalnum() or c in "-_" else "_" for c in session_id)
+        return os.path.join(self.session_dir, f"{safe_id}.json")
+    
+    def _load_session(self, session_id: str) -> SessionData:
+        """Load session from disk with file locking."""
+        filepath = self._get_session_path(session_id)
+        
+        # Check cache first
+        with self._lock:
+            if session_id in self._cache:
+                return self._cache[session_id]
+        
+        # Load from disk
+        if not os.path.exists(filepath):
+            session = SessionData(session_id=session_id)
+            with self._lock:
+                self._cache[session_id] = session
+            return session
+        
+        with FileLock(filepath, self.lock_timeout):
+            try:
+                with open(filepath, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                session = SessionData.from_dict(data)
+            except (json.JSONDecodeError, IOError) as e:
+                logger.warning(f"Failed to load session {session_id}: {e}")
+                session = SessionData(session_id=session_id)
+        
+        with self._lock:
+            self._cache[session_id] = session
+        
+        return session
+    
+    def _save_session(self, session: SessionData) -> bool:
+        """Save session to disk with atomic write."""
+        filepath = self._get_session_path(session.session_id)
+        session.updated_at = datetime.now(timezone.utc).isoformat()
+        
+        # Trim messages if over limit
+        if len(session.messages) > self.max_messages:
+            session.messages = session.messages[-self.max_messages:]
+        
+        with FileLock(filepath, self.lock_timeout):
+            try:
+                # Atomic write: write to temp file, then rename
+                dir_path = os.path.dirname(filepath)
+                with tempfile.NamedTemporaryFile(
+                    mode="w",
+                    encoding="utf-8",
+                    dir=dir_path,
+                    delete=False,
+                    suffix=".tmp"
+                ) as f:
+                    json.dump(session.to_dict(), f, indent=2, ensure_ascii=False)
+                    temp_path = f.name
+                
+                # Atomic rename
+                os.replace(temp_path, filepath)
+                return True
+            except (IOError, OSError) as e:
+                logger.error(f"Failed to save session {session.session_id}: {e}")
+                # Clean up temp file if it exists
+                try:
+                    if 'temp_path' in locals():
+                        os.remove(temp_path)
+                except (IOError, OSError):
+                    pass
+                return False
+    
+    def add_message(
+        self,
+        session_id: str,
+        role: str,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> bool:
+        """
+        Add a message to a session.
+        
+        Args:
+            session_id: The session ID.
+            role: Message role ("user", "assistant", "system").
+            content: Message content.
+            metadata: Optional metadata.
+            
+        Returns:
+            True if saved successfully.
+        """
+        filepath = self._get_session_path(session_id)
+        
+        message = SessionMessage(
+            role=role,
+            content=content,
+            timestamp=time.time(),
+            metadata=metadata or {},
+        )
+        
+        # Use file lock for atomic read-modify-write
+        with FileLock(filepath, self.lock_timeout):
+            # Always reload from disk inside lock to avoid race conditions
+            if os.path.exists(filepath):
+                try:
+                    with open(filepath, "r", encoding="utf-8") as f:
+                        data = json.load(f)
+                    session = SessionData.from_dict(data)
+                except (json.JSONDecodeError, IOError):
+                    session = SessionData(session_id=session_id)
+            else:
+                session = SessionData(session_id=session_id)
+            
+            # Add message
+            session.messages.append(message)
+            session.updated_at = datetime.now(timezone.utc).isoformat()
+            
+            # Trim messages if over limit
+            if len(session.messages) > self.max_messages:
+                session.messages = session.messages[-self.max_messages:]
+            
+            # Write atomically
+            try:
+                dir_path = os.path.dirname(filepath) or "."
+                os.makedirs(dir_path, exist_ok=True)
+                with tempfile.NamedTemporaryFile(
+                    mode="w",
+                    encoding="utf-8",
+                    dir=dir_path,
+                    delete=False,
+                    suffix=".tmp"
+                ) as f:
+                    json.dump(session.to_dict(), f, indent=2, ensure_ascii=False)
+                    temp_path = f.name
+                
+                os.replace(temp_path, filepath)
+                
+                # Update cache
+                with self._lock:
+                    self._cache[session_id] = session
+                
+                return True
+            except (IOError, OSError) as e:
+                logger.error(f"Failed to save session {session_id}: {e}")
+                try:
+                    if 'temp_path' in locals():
+                        os.remove(temp_path)
+                except (IOError, OSError):
+                    pass
+                return False
+    
+    def add_user_message(
+        self,
+        session_id: str,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> bool:
+        """Add a user message to a session."""
+        return self.add_message(session_id, "user", content, metadata)
+    
+    def add_assistant_message(
+        self,
+        session_id: str,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> bool:
+        """Add an assistant message to a session."""
+        return self.add_message(session_id, "assistant", content, metadata)
+    
+    def get_chat_history(
+        self,
+        session_id: str,
+        max_messages: Optional[int] = None,
+    ) -> List[Dict[str, str]]:
+        """
+        Get chat history for a session in LLM-compatible format.
+        
+        Args:
+            session_id: The session ID.
+            max_messages: Maximum messages to return (defaults to store limit).
+            
+        Returns:
+            List of {"role": "user/assistant", "content": "..."} dicts.
+        """
+        session = self._load_session(session_id)
+        limit = max_messages or self.max_messages
+        return session.get_chat_history(limit)
+    
+    def get_session(self, session_id: str) -> SessionData:
+        """Get full session data."""
+        return self._load_session(session_id)
+    
+    def set_agent_info(
+        self,
+        session_id: str,
+        agent_name: Optional[str] = None,
+        user_id: Optional[str] = None,
+    ) -> bool:
+        """Set agent info for a session."""
+        session = self._load_session(session_id)
+        
+        with self._lock:
+            if agent_name:
+                session.agent_name = agent_name
+            if user_id:
+                session.user_id = user_id
+            self._cache[session_id] = session
+        
+        return self._save_session(session)
+    
+    def clear_session(self, session_id: str) -> bool:
+        """Clear all messages from a session."""
+        session = self._load_session(session_id)
+        
+        with self._lock:
+            session.messages.clear()
+            self._cache[session_id] = session
+        
+        return self._save_session(session)
+    
+    def delete_session(self, session_id: str) -> bool:
+        """Delete a session completely."""
+        filepath = self._get_session_path(session_id)
+        
+        with self._lock:
+            if session_id in self._cache:
+                del self._cache[session_id]
+        
+        try:
+            if os.path.exists(filepath):
+                os.remove(filepath)
+            return True
+        except (IOError, OSError) as e:
+            logger.error(f"Failed to delete session {session_id}: {e}")
+            return False
+    
+    def list_sessions(self, limit: int = 50) -> List[Dict[str, Any]]:
+        """List all sessions with metadata."""
+        sessions = []
+        
+        try:
+            for filename in os.listdir(self.session_dir):
+                if filename.endswith(".json"):
+                    filepath = os.path.join(self.session_dir, filename)
+                    try:
+                        with open(filepath, "r", encoding="utf-8") as f:
+                            data = json.load(f)
+                        sessions.append({
+                            "session_id": data.get("session_id", filename[:-5]),
+                            "agent_name": data.get("agent_name"),
+                            "created_at": data.get("created_at"),
+                            "updated_at": data.get("updated_at"),
+                            "message_count": len(data.get("messages", [])),
+                        })
+                    except (json.JSONDecodeError, IOError):
+                        continue
+        except (IOError, OSError):
+            pass
+        
+        # Sort by updated_at descending
+        sessions.sort(key=lambda x: x.get("updated_at", ""), reverse=True)
+        return sessions[:limit]
+    
+    def session_exists(self, session_id: str) -> bool:
+        """Check if a session exists."""
+        filepath = self._get_session_path(session_id)
+        return os.path.exists(filepath)
+    
+    def invalidate_cache(self, session_id: Optional[str] = None) -> None:
+        """Invalidate cache for a session or all sessions."""
+        with self._lock:
+            if session_id:
+                self._cache.pop(session_id, None)
+            else:
+                self._cache.clear()
+
+
+# Global session store instance (lazy initialized)
+_default_store: Optional[DefaultSessionStore] = None
+_store_lock = threading.Lock()
+
+
+def get_default_session_store() -> DefaultSessionStore:
+    """Get the global default session store instance."""
+    global _default_store
+    
+    if _default_store is None:
+        with _store_lock:
+            if _default_store is None:
+                _default_store = DefaultSessionStore()
+    
+    return _default_store

src/praisonai-agents/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.6.0"
+version = "0.6.2"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 readme = "README.md"
 requires-python = ">=3.10"

src/praisonai-agents/tests/unit/session/__init__.py

@@ -0,0 +1 @@
+# Session module tests

src/praisonai-agents/tests/unit/session/test_session_store.py

@@ -0,0 +1,404 @@
+"""
+TDD Tests for Session Store.
+
+Tests for DefaultSessionStore with JSON-based persistence.
+"""
+
+import json
+import os
+import tempfile
+import threading
+import time
+import pytest
+from concurrent.futures import ThreadPoolExecutor
+
+from praisonaiagents.session.store import (
+    DefaultSessionStore,
+    SessionMessage,
+    SessionData,
+    FileLock,
+    DEFAULT_MAX_MESSAGES,
+)
+
+
+class TestSessionMessage:
+    """Tests for SessionMessage dataclass."""
+    
+    def test_create_message(self):
+        """Test creating a session message."""
+        msg = SessionMessage(role="user", content="Hello")
+        assert msg.role == "user"
+        assert msg.content == "Hello"
+        assert msg.timestamp > 0
+        assert msg.metadata == {}
+    
+    def test_message_to_dict(self):
+        """Test converting message to dict."""
+        msg = SessionMessage(role="assistant", content="Hi there!")
+        d = msg.to_dict()
+        assert d["role"] == "assistant"
+        assert d["content"] == "Hi there!"
+        assert "timestamp" in d
+        assert "metadata" in d
+    
+    def test_message_from_dict(self):
+        """Test creating message from dict."""
+        d = {"role": "user", "content": "Test", "timestamp": 123.0, "metadata": {"key": "value"}}
+        msg = SessionMessage.from_dict(d)
+        assert msg.role == "user"
+        assert msg.content == "Test"
+        assert msg.timestamp == 123.0
+        assert msg.metadata == {"key": "value"}
+
+
+class TestSessionData:
+    """Tests for SessionData dataclass."""
+    
+    def test_create_session(self):
+        """Test creating session data."""
+        session = SessionData(session_id="test-123")
+        assert session.session_id == "test-123"
+        assert session.messages == []
+        assert session.created_at is not None
+        assert session.updated_at is not None
+    
+    def test_session_to_dict(self):
+        """Test converting session to dict."""
+        session = SessionData(session_id="test-123", agent_name="Assistant")
+        session.messages.append(SessionMessage(role="user", content="Hello"))
+        d = session.to_dict()
+        assert d["session_id"] == "test-123"
+        assert d["agent_name"] == "Assistant"
+        assert len(d["messages"]) == 1
+    
+    def test_session_from_dict(self):
+        """Test creating session from dict."""
+        d = {
+            "session_id": "test-456",
+            "messages": [{"role": "user", "content": "Hi"}],
+            "agent_name": "Bot",
+        }
+        session = SessionData.from_dict(d)
+        assert session.session_id == "test-456"
+        assert session.agent_name == "Bot"
+        assert len(session.messages) == 1
+    
+    def test_get_chat_history(self):
+        """Test getting chat history in LLM format."""
+        session = SessionData(session_id="test")
+        session.messages.append(SessionMessage(role="user", content="Hello"))
+        session.messages.append(SessionMessage(role="assistant", content="Hi!"))
+        
+        history = session.get_chat_history()
+        assert len(history) == 2
+        assert history[0] == {"role": "user", "content": "Hello"}
+        assert history[1] == {"role": "assistant", "content": "Hi!"}
+    
+    def test_get_chat_history_with_limit(self):
+        """Test getting limited chat history."""
+        session = SessionData(session_id="test")
+        for i in range(10):
+            session.messages.append(SessionMessage(role="user", content=f"Message {i}"))
+        
+        history = session.get_chat_history(max_messages=3)
+        assert len(history) == 3
+        assert history[0]["content"] == "Message 7"
+        assert history[2]["content"] == "Message 9"
+
+
+class TestFileLock:
+    """Tests for FileLock."""
+    
+    def test_acquire_release(self):
+        """Test basic lock acquire and release."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            filepath = os.path.join(tmpdir, "test.json")
+            lock = FileLock(filepath, timeout=1.0)
+            
+            assert lock.acquire()
+            lock.release()
+    
+    def test_context_manager(self):
+        """Test lock as context manager."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            filepath = os.path.join(tmpdir, "test.json")
+            
+            with FileLock(filepath, timeout=1.0):
+                # Lock is held
+                pass
+            # Lock is released
+    
+    def test_concurrent_locks(self):
+        """Test that concurrent locks are serialized."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            filepath = os.path.join(tmpdir, "test.json")
+            results = []
+            
+            def worker(worker_id):
+                with FileLock(filepath, timeout=5.0):
+                    results.append(f"start-{worker_id}")
+                    time.sleep(0.1)
+                    results.append(f"end-{worker_id}")
+            
+            threads = [threading.Thread(target=worker, args=(i,)) for i in range(3)]
+            for t in threads:
+                t.start()
+            for t in threads:
+                t.join()
+            
+            # Check that starts and ends are paired (no interleaving)
+            for i in range(3):
+                start_idx = results.index(f"start-{i}")
+                end_idx = results.index(f"end-{i}")
+                # No other start should be between this start and end
+                for j in range(3):
+                    if i != j:
+                        other_start = results.index(f"start-{j}")
+                        if start_idx < other_start < end_idx:
+                            pytest.fail(f"Lock interleaving detected: {results}")
+
+
+class TestDefaultSessionStore:
+    """Tests for DefaultSessionStore."""
+    
+    @pytest.fixture
+    def temp_store(self):
+        """Create a temporary session store."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            store = DefaultSessionStore(session_dir=tmpdir)
+            yield store
+    
+    def test_add_message(self, temp_store):
+        """Test adding a message."""
+        result = temp_store.add_message("session-1", "user", "Hello")
+        assert result is True
+        
+        history = temp_store.get_chat_history("session-1")
+        assert len(history) == 1
+        assert history[0]["role"] == "user"
+        assert history[0]["content"] == "Hello"
+    
+    def test_add_user_message(self, temp_store):
+        """Test adding a user message."""
+        temp_store.add_user_message("session-1", "Hello")
+        history = temp_store.get_chat_history("session-1")
+        assert history[0]["role"] == "user"
+    
+    def test_add_assistant_message(self, temp_store):
+        """Test adding an assistant message."""
+        temp_store.add_assistant_message("session-1", "Hi there!")
+        history = temp_store.get_chat_history("session-1")
+        assert history[0]["role"] == "assistant"
+    
+    def test_persistence_across_instances(self, temp_store):
+        """Test that sessions persist across store instances."""
+        session_dir = temp_store.session_dir
+        
+        # Add messages with first store
+        temp_store.add_user_message("session-1", "Hello")
+        temp_store.add_assistant_message("session-1", "Hi!")
+        
+        # Create new store instance
+        store2 = DefaultSessionStore(session_dir=session_dir)
+        
+        # Verify messages are restored
+        history = store2.get_chat_history("session-1")
+        assert len(history) == 2
+        assert history[0]["content"] == "Hello"
+        assert history[1]["content"] == "Hi!"
+    
+    def test_session_file_created(self, temp_store):
+        """Test that session file is created on disk."""
+        temp_store.add_user_message("test-session", "Hello")
+        
+        filepath = os.path.join(temp_store.session_dir, "test-session.json")
+        assert os.path.exists(filepath)
+        
+        with open(filepath, "r") as f:
+            data = json.load(f)
+        assert data["session_id"] == "test-session"
+        assert len(data["messages"]) == 1
+    
+    def test_max_messages_limit(self):
+        """Test that messages are trimmed to max limit."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            store = DefaultSessionStore(session_dir=tmpdir, max_messages=5)
+            
+            for i in range(10):
+                store.add_user_message("session-1", f"Message {i}")
+            
+            history = store.get_chat_history("session-1")
+            assert len(history) == 5
+            assert history[0]["content"] == "Message 5"
+            assert history[4]["content"] == "Message 9"
+    
+    def test_clear_session(self, temp_store):
+        """Test clearing a session."""
+        temp_store.add_user_message("session-1", "Hello")
+        temp_store.add_assistant_message("session-1", "Hi!")
+        
+        temp_store.clear_session("session-1")
+        
+        history = temp_store.get_chat_history("session-1")
+        assert len(history) == 0
+    
+    def test_delete_session(self, temp_store):
+        """Test deleting a session."""
+        temp_store.add_user_message("session-1", "Hello")
+        filepath = os.path.join(temp_store.session_dir, "session-1.json")
+        assert os.path.exists(filepath)
+        
+        temp_store.delete_session("session-1")
+        assert not os.path.exists(filepath)
+    
+    def test_list_sessions(self, temp_store):
+        """Test listing sessions."""
+        temp_store.add_user_message("session-1", "Hello")
+        temp_store.add_user_message("session-2", "Hi")
+        temp_store.add_user_message("session-3", "Hey")
+        
+        sessions = temp_store.list_sessions()
+        assert len(sessions) == 3
+        session_ids = [s["session_id"] for s in sessions]
+        assert "session-1" in session_ids
+        assert "session-2" in session_ids
+        assert "session-3" in session_ids
+    
+    def test_session_exists(self, temp_store):
+        """Test checking if session exists."""
+        assert not temp_store.session_exists("session-1")
+        
+        temp_store.add_user_message("session-1", "Hello")
+        assert temp_store.session_exists("session-1")
+    
+    def test_set_agent_info(self, temp_store):
+        """Test setting agent info."""
+        temp_store.add_user_message("session-1", "Hello")
+        temp_store.set_agent_info("session-1", agent_name="TestBot", user_id="user-123")
+        
+        session = temp_store.get_session("session-1")
+        assert session.agent_name == "TestBot"
+        assert session.user_id == "user-123"
+    
+    def test_concurrent_writes(self, temp_store):
+        """Test concurrent writes to same session."""
+        def writer(msg_id):
+            temp_store.add_user_message("session-1", f"Message {msg_id}")
+        
+        with ThreadPoolExecutor(max_workers=5) as executor:
+            futures = [executor.submit(writer, i) for i in range(10)]
+            for f in futures:
+                f.result()
+        
+        history = temp_store.get_chat_history("session-1")
+        assert len(history) == 10
+    
+    def test_sanitize_session_id(self, temp_store):
+        """Test that session IDs are sanitized for filesystem."""
+        temp_store.add_user_message("session/with/slashes", "Hello")
+        temp_store.add_user_message("session:with:colons", "Hi")
+        
+        # Should not raise errors
+        history1 = temp_store.get_chat_history("session/with/slashes")
+        history2 = temp_store.get_chat_history("session:with:colons")
+        assert len(history1) == 1
+        assert len(history2) == 1
+    
+    def test_empty_session_returns_empty_history(self, temp_store):
+        """Test that non-existent session returns empty history."""
+        history = temp_store.get_chat_history("nonexistent")
+        assert history == []
+    
+    def test_invalidate_cache(self, temp_store):
+        """Test cache invalidation."""
+        temp_store.add_user_message("session-1", "Hello")
+        
+        # Modify file directly
+        filepath = os.path.join(temp_store.session_dir, "session-1.json")
+        with open(filepath, "r") as f:
+            data = json.load(f)
+        data["messages"].append({"role": "user", "content": "Direct edit", "timestamp": time.time(), "metadata": {}})
+        with open(filepath, "w") as f:
+            json.dump(data, f)
+        
+        # Without invalidation, cache returns old data
+        history = temp_store.get_chat_history("session-1")
+        assert len(history) == 1  # Cached
+        
+        # After invalidation, new data is loaded
+        temp_store.invalidate_cache("session-1")
+        history = temp_store.get_chat_history("session-1")
+        assert len(history) == 2
+
+
+class TestAgentSessionIntegration:
+    """Tests for Agent integration with session store."""
+    
+    def test_agent_session_persistence(self):
+        """Test that Agent persists session with session_id."""
+        from praisonaiagents import Agent
+        
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Patch the default session directory
+            import praisonaiagents.session.store as store_module
+            original_dir = store_module.DEFAULT_SESSION_DIR
+            store_module.DEFAULT_SESSION_DIR = tmpdir
+            
+            # Reset global store
+            store_module._default_store = None
+            
+            try:
+                # Create agent with session_id
+                agent = Agent(
+                    name="TestAgent",
+                    instructions="You are a test agent.",
+                    session_id="test-session-123",
+                    verbose=False,
+                )
+                
+                # Verify session store is initialized after first chat
+                # (We can't actually call chat without API key, so we test init)
+                agent._init_session_store()
+                
+                assert agent._session_store is not None
+                assert agent._session_store_initialized is True
+            finally:
+                store_module.DEFAULT_SESSION_DIR = original_dir
+                store_module._default_store = None
+    
+    def test_agent_no_session_id_no_persistence(self):
+        """Test that Agent without session_id doesn't use session store."""
+        from praisonaiagents import Agent
+        
+        agent = Agent(
+            name="TestAgent",
+            instructions="You are a test agent.",
+            verbose=False,
+        )
+        
+        agent._init_session_store()
+        
+        assert agent._session_store is None
+        assert agent._session_store_initialized is True
+    
+    def test_agent_with_db_no_session_store(self):
+        """Test that Agent with DB adapter doesn't use session store."""
+        from praisonaiagents import Agent
+        
+        # Mock DB adapter
+        class MockDbAdapter:
+            def on_agent_start(self, **kwargs):
+                return []
+        
+        agent = Agent(
+            name="TestAgent",
+            instructions="You are a test agent.",
+            session_id="test-session",
+            db=MockDbAdapter(),
+            verbose=False,
+        )
+        
+        agent._init_session_store()
+        
+        # Session store should not be used when DB is provided
+        assert agent._session_store is None

src/praisonai-agents/uv.lock

@@ -2422,7 +2422,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.6.0"
+version = "0.6.2"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },

src/praisonai/praisonai.rb

@@ -3,8 +3,8 @@ class Praisonai < Formula
   
     desc "AI tools for various AI applications"
     homepage "https://github.com/MervinPraison/PraisonAI"
-    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v3.0.2.tar.gz"
-    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v3.0.2.tar.gz | shasum -a 256`.split.first
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v3.0.4.tar.gz"
+    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v3.0.4.tar.gz | shasum -a 256`.split.first
     license "MIT"
   
     depends_on "[email protected]"

src/praisonai/praisonai/cli/execution/profiler.py

@@ -419,6 +419,8 @@ class ProfileReport:
             "timestamp": self.timestamp,
             "invocation": self.invocation.to_dict(),
             "timing": self.timing.to_dict(),
+            "timeline": self.timing.to_timeline(),
+            "timeline_diagram": self.to_timeline_diagram(),
             "response_preview": self.response_preview,
         }
         
@@ -444,6 +446,85 @@ class ProfileReport:
         import json
         return json.dumps(self.to_dict(), indent=2, default=str)
     
+    def to_timeline_diagram(self) -> str:
+        """
+        Generate ASCII timeline diagram showing execution phases.
+        
+        Format:
+        ENTER ─────────────────────────────────────────────────────────► RESPONSE
+               │ imports │ init │        network        │
+               │  XXXms  │ XXms │        XXXms          │
+               └─────────┴──────┴───────────────────────┘
+                                                  TOTAL: XXXXms
+        """
+        lines = []
+        total = self.timing.total_ms
+        if total <= 0:
+            return "No timing data available"
+        
+        # Calculate phase widths (proportional to time, min 8 chars)
+        phases = []
+        if self.timing.imports_ms > 0:
+            phases.append(("imports", self.timing.imports_ms))
+        if self.timing.agent_init_ms > 0:
+            phases.append(("init", self.timing.agent_init_ms))
+        if self.timing.execution_ms > 0:
+            phases.append(("network", self.timing.execution_ms))
+        
+        if not phases:
+            phases = [("total", total)]
+        
+        # Scale to fit in ~60 chars
+        scale = 50.0 / total if total > 0 else 1
+        
+        # Build the diagram
+        lines.append("")
+        lines.append("## Timeline Diagram")
+        lines.append("")
+        
+        # Top line with arrow
+        top_line = "ENTER "
+        for name, ms in phases:
+            width = max(8, int(ms * scale))
+            top_line += "─" * width
+        top_line += "► RESPONSE"
+        lines.append(top_line)
+        
+        # Phase names line
+        name_line = "      "
+        for name, ms in phases:
+            width = max(8, int(ms * scale))
+            name_line += "│" + name.center(width - 1)
+        name_line += "│"
+        lines.append(name_line)
+        
+        # Phase times line
+        time_line = "      "
+        for name, ms in phases:
+            width = max(8, int(ms * scale))
+            time_str = f"{ms:.0f}ms"
+            time_line += "│" + time_str.center(width - 1)
+        time_line += "│"
+        lines.append(time_line)
+        
+        # Bottom line
+        bottom_line = "      "
+        for i, (name, ms) in enumerate(phases):
+            width = max(8, int(ms * scale))
+            if i == 0:
+                bottom_line += "└" + "─" * (width - 1)
+            else:
+                bottom_line += "┴" + "─" * (width - 1)
+        bottom_line += "┘"
+        lines.append(bottom_line)
+        
+        # Total line
+        total_line = " " * (len(bottom_line) - 15) + f"TOTAL: {total:.0f}ms"
+        lines.append(total_line)
+        lines.append("")
+        
+        return "\n".join(lines)
+    
     def to_text(self) -> str:
         """Format as human-readable text."""
         lines = []
@@ -459,7 +540,10 @@ class ProfileReport:
         lines.append(f"Version:    {self.invocation.praisonai_version}")
         lines.append("")
         
-        # TIMELINE SECTION (new - shows ENTER → First Response)
+        # TIMELINE DIAGRAM (visual representation)
+        lines.append(self.to_timeline_diagram())
+        
+        # TIMELINE SECTION (shows ENTER → First Response)
         lines.append("## Execution Timeline")
         lines.append("-" * 45)
         timeline = self.timing.to_timeline()

src/praisonai/praisonai/cli/features/queue/worker.py

@@ -220,6 +220,7 @@ class WorkerPool:
             tools = QueueManager.get_tools_for_run(run.run_id)
             
             # Create agent with session_id for history persistence
+            # Agent automatically restores history from JSON store when session_id is provided
             # Note: Agent uses 'llm' parameter, not 'model'
             agent = Agent(
                 name=agent_name,
@@ -230,10 +231,12 @@ class WorkerPool:
                 session_id=agent_config.get("session_id") or run.session_id,  # Use session for history
             )
             
-            # Inject chat history from session store for context continuity
-            if run.chat_history:
+            # Legacy: Inject chat history if provided (for backward compatibility)
+            # This is no longer needed as Agent now has built-in JSON persistence
+            # but we keep it for cases where chat_history is explicitly passed
+            if run.chat_history and not agent.chat_history:
                 agent.chat_history = list(run.chat_history)
-                logger.debug(f"Injected {len(run.chat_history)} messages from session history")
+                logger.debug(f"Injected {len(run.chat_history)} messages from run.chat_history (legacy)")
             
             # Check for cancellation before starting
             if self.scheduler.is_cancelled(run.run_id):

src/praisonai/praisonai/cli/features/tui/session_store.py

@@ -1,10 +1,27 @@
 """
 Session Store for PraisonAI TUI.
 
+DEPRECATED: This module is deprecated in favor of the core SDK session store.
+Use `praisonaiagents.session.DefaultSessionStore` instead, which provides:
+- JSON-based persistence (survives restarts)
+- File locking for multi-process safety
+- Automatic integration with Agent class
+
+This TUI-specific in-memory store is kept for backward compatibility only.
+New code should use the core SDK session store.
+
+Example:
+    from praisonaiagents.session import get_default_session_store
+    store = get_default_session_store()
+    store.add_user_message("session-id", "Hello")
+    history = store.get_chat_history("session-id")
+
 Maintains chat history in memory for session persistence.
 This allows the AI to remember previous messages within a session.
 """
 
+import warnings
+
 import logging
 from dataclasses import dataclass, field
 from typing import Dict, List, Optional

src/praisonai/praisonai/cli/main.py

@@ -64,8 +64,19 @@ import importlib
 # Lazy imports for performance - these are imported when needed, not at module load
 # from praisonai.auto import AutoGenerator  # Lazy: imported in auto/init commands
 # from praisonai.agents_generator import AgentsGenerator  # Lazy: imported when running agents
-from praisonai.inbuilt_tools import *
-from praisonai.inc.config import generate_config
+# REMOVED: from praisonai.inbuilt_tools import * - causes ~3200ms crewai import
+# REMOVED: from praisonai.inc.config import generate_config - causes ~3500ms langchain import
+
+# Lazy import helpers for inbuilt_tools and config
+def _get_inbuilt_tools():
+    """Lazy import inbuilt_tools only when crewai/autogen features are used."""
+    from praisonai import inbuilt_tools
+    return inbuilt_tools
+
+def _get_generate_config():
+    """Lazy import generate_config only when training features are used."""
+    from praisonai.inc.config import generate_config
+    return generate_config
 
 # Lazy import helpers for heavy modules
 def _get_auto_generator():
@@ -116,7 +127,7 @@ AUTOGEN_AVAILABLE = importlib.util.find_spec("autogen") is not None
 PRAISONAI_AVAILABLE = importlib.util.find_spec("praisonaiagents") is not None
 TRAIN_AVAILABLE = importlib.util.find_spec("unsloth") is not None
 
-logging.basicConfig(level=os.environ.get('LOGLEVEL', 'WARNING'), format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=os.environ.get('LOGLEVEL', 'WARNING') or 'WARNING', format='%(asctime)s - %(levelname)s - %(message)s')
 logging.getLogger('alembic').setLevel(logging.ERROR)
 logging.getLogger('gradio').setLevel(logging.ERROR)
 logging.getLogger('gradio').setLevel(os.environ.get('GRADIO_LOGLEVEL', 'WARNING'))
@@ -478,7 +489,7 @@ class PraisonAI:
             config_yaml_destination = os.path.join(os.getcwd(), 'config.yaml')
 
             if not os.path.exists(config_yaml_destination):
-                config = generate_config(
+                config = _get_generate_config()(
                     model_name=args.model,
                     hf_model_name=args.hf,
                     ollama_model_name=args.ollama,
@@ -489,7 +500,7 @@ class PraisonAI:
                 with open('config.yaml', 'w') as f:
                     yaml.dump(config, f, default_flow_style=False, indent=2)
             elif args.model or args.hf or args.ollama or (args.dataset and args.dataset != "yahma/alpaca-cleaned"):
-                config = generate_config(
+                config = _get_generate_config()(
                     model_name=args.model,
                     hf_model_name=args.hf,
                     ollama_model_name=args.ollama,

src/praisonai/praisonai/deploy.py

@@ -57,7 +57,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==3.0.2 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==3.0.4 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

src/praisonai/praisonai/inbuilt_tools/__init__.py

@@ -1,24 +1,28 @@
-# Only try to import autogen_tools if either CrewAI or AG2 is available
-CREWAI_AVAILABLE = False
-AUTOGEN_AVAILABLE = False
+# Lazy availability checks using find_spec (no actual import)
+# This avoids the ~3200ms crewai import at CLI startup
+import importlib.util
+
+CREWAI_AVAILABLE = importlib.util.find_spec("crewai") is not None
+AUTOGEN_AVAILABLE = importlib.util.find_spec("autogen") is not None
 PRAISONAI_TOOLS_AVAILABLE = False
 
-try:
-    from crewai import Agent, Task, Crew
-    CREWAI_AVAILABLE = True
-except ImportError:
-    pass
+# Lazy import helper - only imports when actually needed
+def _get_autogen_tools():
+    """Lazy import autogen_tools only when needed."""
+    global PRAISONAI_TOOLS_AVAILABLE
+    if CREWAI_AVAILABLE or AUTOGEN_AVAILABLE:
+        try:
+            from . import autogen_tools
+            PRAISONAI_TOOLS_AVAILABLE = True
+            return autogen_tools
+        except ImportError:
+            pass
+    return None
 
-try:
-    import autogen
-    AUTOGEN_AVAILABLE = True
-except ImportError:
-    pass
-
-# Only try to import tools if a framework is available
-if CREWAI_AVAILABLE or AUTOGEN_AVAILABLE:
-    try:
-        from .autogen_tools import *
-        PRAISONAI_TOOLS_AVAILABLE = True
-    except ImportError:
-        pass
+# For backward compatibility, provide __getattr__ for lazy access
+def __getattr__(name):
+    """Lazy load autogen_tools exports on demand."""
+    tools_module = _get_autogen_tools()
+    if tools_module and hasattr(tools_module, name):
+        return getattr(tools_module, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

src/praisonai/praisonai/inc/__init__.py

@@ -1,2 +1,12 @@
 # praisonai/inc/__init__.py
-from .models import PraisonAIModel
+# Lazy loading - PraisonAIModel is only imported when accessed
+# This avoids the ~3500ms langchain_openai import at CLI startup
+
+def __getattr__(name):
+    """Lazy load PraisonAIModel only when accessed."""
+    if name == "PraisonAIModel":
+        from .models import PraisonAIModel
+        return PraisonAIModel
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+__all__ = ["PraisonAIModel"]

src/praisonai/praisonai/inc/models.py

@@ -1,7 +1,11 @@
 # praisonai/inc/models.py
+# PERFORMANCE OPTIMIZED: Removed all LangChain imports
+# Uses direct OpenAI SDK for fast startup (~600ms vs ~3200ms with langchain_openai)
 import os
 import logging
 from urllib.parse import urlparse
+import importlib.util
+
 logger = logging.getLogger(__name__)
 _loglevel = os.environ.get('LOGLEVEL', 'INFO').strip().upper() or 'INFO'
 logging.basicConfig(level=_loglevel, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -9,30 +13,33 @@ logging.basicConfig(level=_loglevel, format='%(asctime)s - %(levelname)s - %(mes
 # Constants
 LOCAL_SERVER_API_KEY_PLACEHOLDER = "not-needed"
 
-# Conditionally import modules based on availability
-try:
-    from langchain_openai import ChatOpenAI  # pip install langchain-openai
-    OPENAI_AVAILABLE = True
-except ImportError:
-    OPENAI_AVAILABLE = False
+# Use find_spec for fast availability checks (no actual import)
+# This avoids the ~3200ms langchain_openai import at module load
+OPENAI_AVAILABLE = importlib.util.find_spec("openai") is not None
+GOOGLE_GENAI_AVAILABLE = importlib.util.find_spec("google.generativeai") is not None
+ANTHROPIC_AVAILABLE = importlib.util.find_spec("anthropic") is not None
+COHERE_AVAILABLE = importlib.util.find_spec("cohere") is not None
 
-try:
-    from langchain_google_genai import ChatGoogleGenerativeAI  # pip install langchain-google-genai
-    GOOGLE_GENAI_AVAILABLE = True
-except ImportError:
-    GOOGLE_GENAI_AVAILABLE = False
+# Lazy import helpers for provider SDKs
+def _get_openai_client():
+    """Lazy import OpenAI client."""
+    from openai import OpenAI
+    return OpenAI
 
-try:
-    from langchain_anthropic import ChatAnthropic  # pip install langchain-anthropic
-    ANTHROPIC_AVAILABLE = True
-except ImportError:
-    ANTHROPIC_AVAILABLE = False
+def _get_google_genai():
+    """Lazy import Google Generative AI."""
+    import google.generativeai as genai
+    return genai
 
-try:
-    from langchain_cohere import ChatCohere  # pip install langchain-cohere
-    COHERE_AVAILABLE = True
-except ImportError:
-    COHERE_AVAILABLE = False
+def _get_anthropic_client():
+    """Lazy import Anthropic client."""
+    from anthropic import Anthropic
+    return Anthropic
+
+def _get_cohere_client():
+    """Lazy import Cohere client."""
+    import cohere
+    return cohere
 
 class PraisonAIModel:
     def __init__(self, model=None, api_key_var=None, base_url=None, api_key=None):
@@ -100,56 +107,47 @@ class PraisonAIModel:
 
     def get_model(self):
         """
-        Returns an instance of the langchain Chat client with the configured parameters.
+        Returns an instance of the native SDK client with the configured parameters.
+        
+        PERFORMANCE: Uses direct SDK clients instead of LangChain wrappers.
+        This saves ~2600ms on import (OpenAI SDK ~600ms vs langchain_openai ~3200ms).
 
         Returns:
-            Chat: An instance of the langchain Chat client.
+            Client: An instance of the native SDK client (OpenAI, Anthropic, etc.)
         """
         if self.model.startswith("google/"):
             if GOOGLE_GENAI_AVAILABLE:
-                return ChatGoogleGenerativeAI(
-                    model=self.model_name,
-                    google_api_key=self.api_key
-                )
+                genai = _get_google_genai()
+                genai.configure(api_key=self.api_key)
+                return genai.GenerativeModel(self.model_name)
             else:
                 raise ImportError(
-                    "Required Langchain Integration 'langchain-google-genai' not found. "
-                    "Please install with 'pip install langchain-google-genai'"
+                    "Required package 'google-generativeai' not found. "
+                    "Please install with 'pip install google-generativeai'"
                 )
         elif self.model.startswith("cohere/"):
             if COHERE_AVAILABLE:
-                return ChatCohere(
-                    model=self.model_name,
-                    cohere_api_key=self.api_key,
-                )
+                cohere = _get_cohere_client()
+                return cohere.Client(api_key=self.api_key)
             else:
                 raise ImportError(
-                    "Required Langchain Integration 'langchain-cohere' not found. "
-                    "Please install with 'pip install langchain-cohere'"
+                    "Required package 'cohere' not found. "
+                    "Please install with 'pip install cohere'"
                 )
         elif self.model.startswith("anthropic/"):
             if ANTHROPIC_AVAILABLE:
-                return ChatAnthropic(
-                    model=self.model_name,
-                    anthropic_api_key=self.api_key,
-                )
+                Anthropic = _get_anthropic_client()
+                return Anthropic(api_key=self.api_key)
             else:
                 raise ImportError(
-                    "Required Langchain Integration 'langchain-anthropic' not found. "
-                    "Please install with 'pip install langchain-anthropic'"
+                    "Required package 'anthropic' not found. "
+                    "Please install with 'pip install anthropic'"
                 )
         elif OPENAI_AVAILABLE:
-            chat_kwargs = {
-                "model": self.model_name,
-                "api_key": self.api_key,
-                "base_url": self.base_url,
-            }
-            # Certain OpenAI models (e.g., gpt-5-* family) only allow temperature=1
-            if isinstance(self.model_name, str) and self.model_name.startswith("gpt-5"):
-                chat_kwargs["temperature"] = 1
-            return ChatOpenAI(**chat_kwargs)
+            OpenAI = _get_openai_client()
+            return OpenAI(api_key=self.api_key, base_url=self.base_url)
         else:
             raise ImportError(
-                "Required Langchain Integration 'langchain-openai' not found. "
-                "Please install with 'pip install langchain-openai'"
+                "Required package 'openai' not found. "
+                "Please install with 'pip install openai'"
             )

src/praisonai/praisonai/version.py

@@ -1 +1 @@
-__version__ = "3.0.2"
+__version__ = "3.0.4"

src/praisonai/pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=0.6.0",
+    "praisonaiagents>=0.6.2",
     "python-dotenv>=0.19.0",
     "instructor>=1.3.3",
     "PyYAML>=6.0",

src/praisonai/uv.lock

@@ -4276,7 +4276,7 @@ requires-dist = [
     { name = "praisonai-tools", marker = "extra == 'autogen'", specifier = ">=0.1.0" },
     { name = "praisonai-tools", marker = "extra == 'autogen-v4'", specifier = ">=0.1.0" },
     { name = "praisonai-tools", marker = "extra == 'crewai'", specifier = ">=0.1.0" },
-    { name = "praisonaiagents", specifier = ">=0.6.0" },
+    { name = "praisonaiagents", specifier = ">=0.6.2" },
     { name = "pyautogen", marker = "extra == 'autogen'", specifier = "==0.2.29" },
     { name = "pydantic", marker = "extra == 'chat'", specifier = "<=2.10.1" },
     { name = "pydantic", marker = "extra == 'code'", specifier = "<=2.10.1" },
@@ -4324,7 +4324,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.6.0"
+version = "0.6.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
@@ -4333,9 +4333,9 @@ dependencies = [
     { name = "pydantic" },
     { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4b/3c/a25740d7e3da4ebea0d83319d412650a016d91b6eb2f2653df1b28a3882f/praisonaiagents-0.6.0.tar.gz", hash = "sha256:f83528f6f1c0adea17cea25a1ea93f660e46ba43002e354717501e82112d9a96", size = 780850, upload-time = "2025-12-31T18:50:35.35Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ea/d0/42418977331fb9a019331c49ee2eaf66c6dc6967725592a6a8bfb7e529ca/praisonaiagents-0.6.2.tar.gz", hash = "sha256:36d48b4c8b2915671033a05bb3983c4e613acdcc2fd8b3547271a6102f0c0928", size = 785586, upload-time = "2026-01-02T05:42:43.766Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8e/18/f4f8360024ef26806831dde4ba3dad23950a4d94dde86085dde510ef1833/praisonaiagents-0.6.0-py3-none-any.whl", hash = "sha256:416c4550b6460b0866c1d59b284aacb86f23d849b38e75542f7056e530e84d80", size = 724880, upload-time = "2025-12-31T18:50:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/62/aa/b3a6daeca388a975d4d21fc3e93847be2379726c5e7428d4efc28a31238d/praisonaiagents-0.6.2-py3-none-any.whl", hash = "sha256:440e45851dab829e9019b0ab35d80a2fa5d7c83a5aadb7269412cc119ede7890", size = 730473, upload-time = "2026-01-02T05:42:41.989Z" },
 ]
 
 [[package]]