From 781874cb9f04cc0c608b1a3d636f17e9c6d28143 Mon Sep 17 00:00:00 2001
From: RadeenXALNW <radeensust@gmail.com>
Date: Fri, 20 Jun 2025 16:26:04 +0000
Subject: [PATCH] added sdk support

---
 debug.py                               |  272 +++++++
 new-test-2/__init__.py                 |    0
 new-test-2/agent.py                    |   55 ++
 new-test-2/main.py                     |   71 ++
 new-test-2/requirements.txt            |    4 +
 new-test-2/runagent.config.json        |   17 +
 runagent/__init__.py                   |   22 +-
 runagent/cli/commands.py               | 1008 +++++++++++++-----------
 runagent/cli/main.py                   |    6 +-
 runagent/client/__init__.py            |  914 +--------------------
 runagent/client/agents.py              |  165 ++++
 runagent/client/config.py              |  193 +++++
 runagent/client/deployment/__init__.py |    8 +
 runagent/client/deployment/local.py    |  285 +++++++
 runagent/client/deployment/remote.py   |  160 ++++
 runagent/client/exceptions.py          |   37 +-
 runagent/client/sdk.py                 |  571 ++++++++++++++
 runagent/client/template_manager.py    |  167 ++++
 runagent/constants.py                  |    2 +-
 runagent/test/debug_sdk.py             |   81 ++
 runagent/test/sdk_test.py              |   38 +
 runagent/test/test_http.py             |   62 ++
 sdk-agent/__init__.py                  |    0
 sdk-agent/agent.py                     |   55 ++
 sdk-agent/main.py                      |   71 ++
 sdk-agent/requirements.txt             |    4 +
 sdk-agent/runagent.config.json         |   17 +
 27 files changed, 2900 insertions(+), 1385 deletions(-)
 create mode 100644 debug.py
 create mode 100644 new-test-2/__init__.py
 create mode 100644 new-test-2/agent.py
 create mode 100644 new-test-2/main.py
 create mode 100644 new-test-2/requirements.txt
 create mode 100644 new-test-2/runagent.config.json
 create mode 100644 runagent/client/agents.py
 create mode 100644 runagent/client/config.py
 create mode 100644 runagent/client/deployment/__init__.py
 create mode 100644 runagent/client/deployment/local.py
 create mode 100644 runagent/client/deployment/remote.py
 create mode 100644 runagent/client/sdk.py
 create mode 100644 runagent/client/template_manager.py
 create mode 100644 runagent/test/debug_sdk.py
 create mode 100644 runagent/test/sdk_test.py
 create mode 100644 runagent/test/test_http.py
 create mode 100644 sdk-agent/__init__.py
 create mode 100644 sdk-agent/agent.py
 create mode 100644 sdk-agent/main.py
 create mode 100644 sdk-agent/requirements.txt
 create mode 100644 sdk-agent/runagent.config.json

diff --git a/debug.py b/debug.py
new file mode 100644
index 0000000..fa20d9d
--- /dev/null
+++ b/debug.py
@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+"""
+Debug script to identify why agent 732e45b2 is failing
+"""
+
+import sys
+import importlib.util
+import traceback
+import os
+from pathlib import Path
+
+def debug_agent(agent_id="d6594457"):
+    """Debug the specific agent to find the exact error"""
+    
+    print(f"🔍 Debugging agent: {agent_id}")
+    print("=" * 50)
+    
+    # 1. Check agent directory
+    agent_dir = Path(f"deployments/{agent_id}")
+    print(f"📁 Agent directory: {agent_dir}")
+    print(f"📁 Directory exists: {agent_dir.exists()}")
+    
+    if not agent_dir.exists():
+        print("❌ Agent directory not found!")
+        return
+    
+    # 2. List files
+    print(f"📄 Files in directory:")
+    for item in agent_dir.iterdir():
+        size = item.stat().st_size if item.is_file() else "DIR"
+        print(f"   - {item.name} ({size} bytes)")
+    
+    # 3. Check main.py exists
+    main_file = agent_dir / "main.py"
+    print(f"\n📄 main.py exists: {main_file.exists()}")
+    
+    if not main_file.exists():
+        print("❌ main.py not found!")
+        return
+    
+    # 4. Check main.py content
+    print(f"\n📄 main.py content (first 500 chars):")
+    try:
+        content = main_file.read_text()
+        print(content[:500] + ("..." if len(content) > 500 else ""))
+        print(f"\n📄 File size: {len(content)} characters")
+        print(f"📄 Has 'def run(': {'def run(' in content}")
+    except Exception as e:
+        print(f"❌ Error reading main.py: {e}")
+        return
+    
+    # 5. Check requirements.txt
+    req_file = agent_dir / "requirements.txt"
+    print(f"\n📋 requirements.txt exists: {req_file.exists()}")
+    if req_file.exists():
+        try:
+            reqs = req_file.read_text()
+            print(f"📋 Requirements:\n{reqs}")
+        except Exception as e:
+            print(f"❌ Error reading requirements.txt: {e}")
+    
+    # 6. Check .env file
+    env_file = agent_dir / ".env"
+    print(f"\n🔐 .env file exists: {env_file.exists()}")
+    if env_file.exists():
+        try:
+            env_content = env_file.read_text()
+            # Don't print actual keys, just show structure
+            lines = env_content.strip().split('\n')
+            print(f"🔐 .env has {len(lines)} lines")
+            for line in lines:
+                if '=' in line:
+                    key = line.split('=')[0]
+                    print(f"   - {key}=***")
+        except Exception as e:
+            print(f"❌ Error reading .env: {e}")
+    
+    # 7. Try to import main.py
+    print(f"\n🔄 Attempting to import main.py...")
+    
+    # Save original path
+    original_path = sys.path.copy()
+    
+    try:
+        # Add agent directory to Python path
+        sys.path.insert(0, str(agent_dir))
+        
+        # Try to import
+        spec = importlib.util.spec_from_file_location("main", main_file)
+        if spec is None:
+            print("❌ Could not create module spec")
+            return
+        
+        print("✅ Module spec created successfully")
+        
+        main_module = importlib.util.module_from_spec(spec)
+        print("✅ Module object created successfully")
+        
+        # Try to execute the module
+        print("🔄 Executing module...")
+        spec.loader.exec_module(main_module)
+        print("✅ Module executed successfully")
+        
+        # Check for run function
+        if hasattr(main_module, 'run'):
+            print("✅ 'run' function found")
+            print(f"✅ 'run' is callable: {callable(main_module.run)}")
+            
+            # Try to call the run function
+            print("\n🔄 Testing run function with sample input...")
+            test_input = {
+                "messages": [{"role": "user", "content": "Hello test"}],
+                "config": {}
+            }
+            
+            try:
+                result = main_module.run(test_input)
+                print("✅ Run function executed successfully!")
+                print(f"📤 Result type: {type(result)}")
+                print(f"📤 Result: {result}")
+                
+                # Check result format
+                if isinstance(result, dict):
+                    print("✅ Result is a dictionary")
+                    if 'success' in result:
+                        print(f"✅ Has 'success' key: {result['success']}")
+                    if 'result' in result:
+                        print(f"✅ Has 'result' key: {type(result['result'])}")
+                    if 'errors' in result:
+                        print(f"⚠️ Has 'errors' key: {result['errors']}")
+                else:
+                    print(f"⚠️ Result is not a dictionary: {type(result)}")
+                
+            except Exception as e:
+                print(f"❌ Error calling run function: {e}")
+                print(f"📋 Traceback:\n{traceback.format_exc()}")
+        else:
+            print("❌ 'run' function not found!")
+            print(f"📋 Available attributes: {[attr for attr in dir(main_module) if not attr.startswith('_')]}")
+    
+    except Exception as e:
+        print(f"❌ Error during import: {e}")
+        print(f"📋 Traceback:\n{traceback.format_exc()}")
+    
+    finally:
+        # Restore original Python path
+        sys.path = original_path
+        print(f"\n🔄 Python path restored")
+    
+    # 8. Check environment variables
+    print(f"\n🔐 Environment variables check:")
+    important_env_vars = ['OPENAI_API_KEY', 'PYTHONPATH']
+    for var in important_env_vars:
+        value = os.environ.get(var)
+        if value:
+            print(f"   - {var}: {'***' if 'KEY' in var else value}")
+        else:
+            print(f"   - {var}: Not set")
+    
+    # 9. Check Python environment
+    print(f"\n🐍 Python environment:")
+    print(f"   - Python version: {sys.version}")
+    print(f"   - Python executable: {sys.executable}")
+    print(f"   - Current working directory: {os.getcwd()}")
+    
+    # 10. Check installed packages relevant to the agent
+    print(f"\n📦 Checking installed packages:")
+    packages_to_check = ['langchain', 'langchain_openai', 'openai', 'python-dotenv']
+    
+    for package in packages_to_check:
+        try:
+            __import__(package)
+            print(f"   ✅ {package}: Installed")
+        except ImportError:
+            print(f"   ❌ {package}: Not installed")
+        except Exception as e:
+            print(f"   ⚠️ {package}: Error - {e}")
+    
+    print("\n" + "=" * 50)
+    print("🔍 Debug complete!")
+
+
+def install_missing_dependencies():
+    """Install missing dependencies for the agent"""
+    print("📦 Installing missing dependencies...")
+    
+    import subprocess
+    
+    requirements = [
+        "langchain==0.1.0",
+        "langchain-openai==0.0.5", 
+        "openai==1.12.0",
+        "python-dotenv==1.0.0"
+    ]
+    
+    for req in requirements:
+        try:
+            print(f"   Installing {req}...")
+            subprocess.check_call([
+                sys.executable, "-m", "pip", "install", req, "--quiet"
+            ])
+            print(f"   ✅ {req} installed")
+        except subprocess.CalledProcessError as e:
+            print(f"   ❌ Failed to install {req}: {e}")
+
+
+def fix_env_file(agent_id="732e45b2"):
+    """Create or fix .env file for the agent"""
+    agent_dir = Path(f"deployments/{agent_id}")
+    env_file = agent_dir / ".env"
+    
+    print(f"🔐 Fixing .env file for agent {agent_id}")
+    
+    # Create a basic .env file with placeholder
+    env_content = """# RunAgent Environment Variables
+OPENAI_API_KEY=your-openai-api-key-here
+
+# Note: Replace 'your-openai-api-key-here' with your actual OpenAI API key
+# You can get one from: https://platform.openai.com/api-keys
+"""
+    
+    try:
+        with open(env_file, 'w') as f:
+            f.write(env_content)
+        print(f"✅ Created .env file at {env_file}")
+        print("⚠️ Remember to add your actual OpenAI API key!")
+    except Exception as e:
+        print(f"❌ Failed to create .env file: {e}")
+
+
+def quick_fix_all(agent_id="732e45b2"):
+    """Apply all quick fixes"""
+    print("🔧 Applying quick fixes...")
+    print("=" * 50)
+    
+    # 1. Install dependencies
+    install_missing_dependencies()
+    
+    # 2. Fix .env file
+    fix_env_file(agent_id)
+    
+    # 3. Set temporary API key for testing
+    os.environ['OPENAI_API_KEY'] = 'test-key-for-debugging'
+    print("🔐 Set temporary OPENAI_API_KEY for testing")
+    
+    print("=" * 50)
+    print("✅ Quick fixes applied!")
+
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Debug RunAgent local agent")
+    parser.add_argument("--agent-id", default="732e45b2", help="Agent ID to debug")
+    parser.add_argument("--fix", action="store_true", help="Apply quick fixes")
+    parser.add_argument("--install-deps", action="store_true", help="Install missing dependencies")
+    parser.add_argument("--fix-env", action="store_true", help="Fix .env file")
+    
+    args = parser.parse_args()
+    
+    if args.fix:
+        quick_fix_all(args.agent_id)
+        print("\n" + "=" * 50)
+    
+    if args.install_deps:
+        install_missing_dependencies()
+    
+    if args.fix_env:
+        fix_env_file(args.agent_id)
+    
+    # Always run debug
+    debug_agent(args.agent_id)
\ No newline at end of file
diff --git a/new-test-2/__init__.py b/new-test-2/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/new-test-2/agent.py b/new-test-2/agent.py
new file mode 100644
index 0000000..5094b47
--- /dev/null
+++ b/new-test-2/agent.py
@@ -0,0 +1,55 @@
+from typing import Dict, Any
+from langchain_openai import ChatOpenAI
+from langchain.chains import ConversationChain
+from langchain.memory import ConversationBufferMemory
+from langchain_core.messages import HumanMessage, AIMessage
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+class LangChainBasicAgent:
+    """Basic LangChain agent with conversation memory"""
+    
+    def __init__(self, config: Dict[str, Any] = None):
+        self.config = config or {}
+        self.llm = ChatOpenAI(
+            temperature=self.config.get("temperature", 0.7),
+            model=self.config.get("model", "gpt-4o-mini"),
+            api_key=os.getenv("OPENAI_API_KEY")
+        )
+        self.memory = ConversationBufferMemory()
+        self.conversation = ConversationChain(
+            llm=self.llm,
+            memory=self.memory,
+            verbose=self.config.get("verbose", False)
+        )
+    
+    def process_message(self, message: str) -> str:
+        """Process a single message and return response"""
+        try:
+            response = self.conversation.predict(input=message)
+            return response
+        except Exception as e:
+            raise Exception(f"Error processing message: {str(e)}")
+    
+    def process_messages(self, messages: list) -> str:
+        """Process a list of messages and return the final response"""
+        if not messages:
+            return "No messages provided"
+        
+        # Add previous messages to memory (except the last one)
+        for msg in messages[:-1]:
+            if msg.get("role") == "user":
+                self.memory.chat_memory.add_user_message(msg["content"])
+            elif msg.get("role") == "assistant":
+                self.memory.chat_memory.add_ai_message(msg["content"])
+        
+        # Process the last message
+        last_message = messages[-1]["content"]
+        return self.process_message(last_message)
+    
+    def get_conversation_history(self) -> list:
+        """Get the conversation history"""
+        return self.memory.chat_memory.messages
\ No newline at end of file
diff --git a/new-test-2/main.py b/new-test-2/main.py
new file mode 100644
index 0000000..678b515
--- /dev/null
+++ b/new-test-2/main.py
@@ -0,0 +1,71 @@
+from typing import Dict, Any
+import time
+from agent import LangChainBasicAgent
+
+def run(input_data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Main entry point for the LangChain Basic agent
+    
+    Args:
+        input_data: Dictionary containing:
+            - messages: List of message objects with 'role' and 'content'
+            - config: Optional configuration parameters
+            
+    Returns:
+        Dictionary with result, errors, and success status
+    """
+    start_time = time.time()
+    
+    try:
+        # Extract configuration
+        config = input_data.get("config", {})
+        messages = input_data.get("messages", [])
+        
+        if not messages:
+            return {
+                "result": {
+                    "type": "string",
+                    "content": "No messages provided",
+                    "metadata": {
+                        "execution_time": time.time() - start_time
+                    }
+                },
+                "errors": ["No messages provided"],
+                "success": False
+            }
+        
+        # Initialize agent
+        agent = LangChainBasicAgent(config)
+        
+        # Process messages
+        response = agent.process_messages(messages)
+        
+        # Calculate execution time
+        execution_time = time.time() - start_time
+        
+        return {
+            "result": {
+                "type": "string",
+                "content": response,
+                "metadata": {
+                    "model_used": config.get("model", "gpt-4"),
+                    "framework": "langchain",
+                    "template": "basic",
+                    "execution_time": execution_time,
+                    "conversation_length": len(messages)
+                }
+            },
+            "errors": [],
+            "success": True
+        }
+        
+    except Exception as e:
+        execution_time = time.time() - start_time
+        return {
+            "result": None,
+            "errors": [str(e)],
+            "success": False,
+            "metadata": {
+                "execution_time": execution_time
+            }
+        }
\ No newline at end of file
diff --git a/new-test-2/requirements.txt b/new-test-2/requirements.txt
new file mode 100644
index 0000000..762acbe
--- /dev/null
+++ b/new-test-2/requirements.txt
@@ -0,0 +1,4 @@
+langchain
+langchain-openai
+openai
+python-dotenv
diff --git a/new-test-2/runagent.config.json b/new-test-2/runagent.config.json
new file mode 100644
index 0000000..b12c578
--- /dev/null
+++ b/new-test-2/runagent.config.json
@@ -0,0 +1,17 @@
+{
+  "agent_name": "new-test-2",
+  "framework": "langchain",
+  "template": "basic",
+  "version": "0.1.0",
+  "created_at": "2025-06-17 13:42:03",
+  "template_source": {
+    "repo_url": "https://github.com/runagent-dev/runagent.git",
+    "branch": "radeen/cli-update",
+    "path": "templates/langchain/basic"
+  },
+  "architecture": {
+    "main_file": "main.py",
+    "agent_file": "agent.py",
+    "entry_point": "run"
+  }
+}
\ No newline at end of file
diff --git a/runagent/__init__.py b/runagent/__init__.py
index a8e2a34..f0a95a8 100644
--- a/runagent/__init__.py
+++ b/runagent/__init__.py
@@ -1,15 +1,25 @@
-# runagent/__init__.py
 """
 RunAgent - Deploy and manage AI agents easily.
 
 This package provides both a CLI and SDK for deploying and managing AI agents
-built with frameworks like LangGraph.
+built with frameworks like LangGraph, LangChain, and LlamaIndex.
 """
 
 __version__ = "0.1.0"
 
-# from .client import RunAgentClient
-# from .client.exceptions import RunAgentClientError, AuthenticationError
+# Import the main SDK components
+from .client import RunAgentSDK, RunAgentError, AuthenticationError, ValidationError, ConnectionError, ServerError
 
-# # Expose the client as the main interface
-# __all__ = ["RunAgentClient", "RunAgentClientError", "AuthenticationError"]
+# Main export - this is what was missing!
+RunAgent = RunAgentSDK
+
+# Expose the main components for easy import
+__all__ = [
+    "RunAgent", 
+    "RunAgentSDK",
+    "RunAgentError", 
+    "AuthenticationError",
+    "ValidationError", 
+    "ConnectionError",
+    "ServerError"
+]
diff --git a/runagent/cli/commands.py b/runagent/cli/commands.py
index 321fb46..bfdf06f 100644
--- a/runagent/cli/commands.py
+++ b/runagent/cli/commands.py
@@ -1,6 +1,24 @@
+"""
+CLI commands that use the restructured SDK internally.
+"""
+
 import click
-import inquirer
-from runagent.client import RunAgentClient
+import json
+import requests
+from pathlib import Path
+from rich.console import Console
+
+# Import the new SDK
+from runagent import RunAgent
+from runagent.client.exceptions import (
+    RunAgentError,
+    AuthenticationError,
+    ValidationError,
+    TemplateError,
+    ConnectionError
+)
+
+console = Console()
 
 
 @click.command()
@@ -9,285 +27,343 @@
 @click.option('--force', is_flag=True, help='Force reconfiguration')
 def setup(api_key, base_url, force):
     """Setup RunAgent authentication"""
-    client = RunAgentClient(cli_mode=True)  # Enable interactive mode
-    client.setup(api_key=api_key, base_url=base_url, force=force)
+    try:
+        sdk = RunAgent()
+        
+        # Check if already configured
+        if sdk.is_configured() and not force:
+            config_status = sdk.get_config_status()
+            console.print("⚠️ RunAgent is already configured:")
+            console.print(f"   Base URL: [blue]{config_status.get('base_url')}[/blue]")
+            console.print(f"   User: [green]{config_status.get('user_info', {}).get('email', 'Unknown')}[/green]")
+            
+            if not click.confirm("Do you want to reconfigure?"):
+                return
+        
+        # Configure SDK
+        sdk.configure(api_key=api_key, base_url=base_url, save=True)
+        
+        console.print("✅ [green]Setup completed successfully![/green]")
+        
+        # Show user info
+        config_status = sdk.get_config_status()
+        user_info = config_status.get('user_info', {})
+        if user_info:
+            console.print("\n👤 [bold]User Information:[/bold]")
+            for key, value in user_info.items():
+                console.print(f"   {key}: [cyan]{value}[/cyan]")
+        
+    except AuthenticationError as e:
+        console.print(f"❌ [red]Authentication failed:[/red] {e}")
+        raise click.ClickException("Setup failed")
+    except Exception as e:
+        console.print(f"❌ [red]Setup error:[/red] {e}")
+        raise click.ClickException("Setup failed")
 
 
 @click.command()
 @click.option('--yes', is_flag=True, help='Skip confirmation')
 def teardown(yes):
     """Remove RunAgent configuration"""
-    client = RunAgentClient(cli_mode=True)  # Enable interactive mode
-    client.teardown(confirm=yes)
+    try:
+        sdk = RunAgent()
+        
+        if not yes:
+            config_status = sdk.get_config_status()
+            if config_status.get('configured'):
+                console.print("📋 [bold]Current configuration:[/bold]")
+                console.print(f"   Base URL: [blue]{config_status.get('base_url')}[/blue]")
+                user_info = config_status.get('user_info', {})
+                if user_info.get('email'):
+                    console.print(f"   User: [green]{user_info.get('email')}[/green]")
+            
+            if not click.confirm("⚠️ This will remove all RunAgent configuration. Continue?"):
+                console.print("Teardown cancelled.")
+                return
+        
+        # Clear configuration
+        sdk.config.clear()
+        
+        console.print("✅ [green]RunAgent teardown completed successfully![/green]")
+        console.print("💡 Run [cyan]'runagent setup --api-key <key>'[/cyan] to reconfigure")
+        
+    except Exception as e:
+        console.print(f"❌ [red]Teardown error:[/red] {e}")
+        raise click.ClickException("Teardown failed")
 
 
 @click.command()
 @click.option('--folder', help='Project folder name')
-@click.option('--framework', default=None, help='Framework to use (langchain, langgraph, llamaindex). Defaults to langchain if not specified')
-@click.option('--template', default=None, help='Template variant (basic, advanced). Defaults to basic if not specified')
-@click.option('--non-interactive', is_flag=True, help='Skip interactive prompts and use defaults (langchain/basic)')
-def init(folder, framework, template, non_interactive):
-    """Initialize a new RunAgent project
-    
-    Examples:
-      runagent init                                    # Interactive mode
-      runagent init --non-interactive                  # Use defaults (langchain/basic)  
-      runagent init --framework langgraph             # Specify framework, prompt for template
-      runagent init --framework langchain --template advanced  # Specify both (no prompts)
-    """
-    
-    # Determine if we should use CLI mode
-    # CLI mode is disabled if --non-interactive is used OR if both framework and template are provided
-    use_cli_mode = not non_interactive and not (framework and template)
+@click.option('--framework', default=None, help='Framework to use (langchain, langgraph, llamaindex)')
+@click.option('--template', default=None, help='Template variant (basic, advanced)')
+@click.option('--non-interactive', is_flag=True, help='Skip interactive prompts')
+@click.option('--overwrite', is_flag=True, help='Overwrite existing folder')
+def init(folder, framework, template, non_interactive, overwrite):
+    """Initialize a new RunAgent project"""
     
-    client = RunAgentClient(cli_mode=use_cli_mode)
-    
-    # Call the init method
-    success = client.init(
-        framework=framework, 
-        template=template, 
-        folder=folder
-    )
-    
-    if not success:
+    try:
+        sdk = RunAgent()
+        
+        # Get folder name
+        if not folder:
+            if non_interactive:
+                folder = "runagent-project"
+            else:
+                folder = click.prompt("📁 Project folder name", default="runagent-project")
+        
+        # Interactive framework selection
+        if not non_interactive and not framework:
+            templates = sdk.list_templates()
+            frameworks = list(templates.keys())
+            
+            console.print("🎯 [bold]Available frameworks:[/bold]")
+            for i, fw in enumerate(frameworks, 1):
+                console.print(f"  {i}. {fw}")
+            
+            choice = click.prompt(
+                "Select framework",
+                type=click.IntRange(1, len(frameworks)),
+                default=1
+            )
+            framework = frameworks[choice - 1]
+        
+        # Interactive template selection
+        if not non_interactive and not template:
+            templates = sdk.list_templates(framework)
+            template_list = templates.get(framework, ['basic'])
+            
+            console.print(f"\n🧱 [bold]Available templates for {framework}:[/bold]")
+            for i, tmpl in enumerate(template_list, 1):
+                console.print(f"  {i}. {tmpl}")
+            
+            choice = click.prompt(
+                "Select template",
+                type=click.IntRange(1, len(template_list)),
+                default=1
+            )
+            template = template_list[choice - 1]
+        
+        # Use defaults if not specified
+        framework = framework or "langchain"
+        template = template or "basic"
+        
+        console.print(f"\n🚀 [bold]Initializing project:[/bold]")
+        console.print(f"   Folder: [cyan]{folder}[/cyan]")
+        console.print(f"   Framework: [magenta]{framework}[/magenta]")
+        console.print(f"   Template: [yellow]{template}[/yellow]")
+        
+        # Initialize project
+        success = sdk.init_project(
+            folder=folder,
+            framework=framework,
+            template=template,
+            overwrite=overwrite
+        )
+        
+        if success:
+            console.print(f"\n✅ [green]Project initialized successfully![/green]")
+            console.print(f"📁 Created: [cyan]{folder}[/cyan]")
+            
+            # Show next steps
+            console.print("\n📝 [bold]Next steps:[/bold]")
+            console.print(f"  1️⃣ [cyan]cd {folder}[/cyan]")
+            console.print(f"  2️⃣ Update your API keys in [yellow].env[/yellow] file")
+            console.print(f"  3️⃣ Test locally: [cyan]python main.py[/cyan]")
+            console.print(f"  4️⃣ Deploy: [cyan]runagent deploy-local --folder {folder}[/cyan]")
+        
+    except TemplateError as e:
+        console.print(f"❌ [red]Template error:[/red] {e}")
+        raise click.ClickException("Project initialization failed")
+    except FileExistsError as e:
+        console.print(f"❌ [red]Folder exists:[/red] {e}")
+        console.print("💡 Use [cyan]--overwrite[/cyan] to force initialization")
+        raise click.ClickException("Project initialization failed")
+    except Exception as e:
+        console.print(f"❌ [red]Initialization error:[/red] {e}")
         raise click.ClickException("Project initialization failed")
 
 
 @click.command()
 @click.option('--list', 'action_list', is_flag=True, help='List all available templates')
-@click.option('--info', 'action_info', is_flag=True, help='Get detailed information about a specific template')
+@click.option('--info', 'action_info', is_flag=True, help='Get detailed template information')
 @click.option('--framework', help='Framework name (required for --info)')
 @click.option('--template', help='Template name (required for --info)')
-@click.option('--filter-framework', help='Filter templates by framework when listing')
-@click.option('--format', type=click.Choice(['table', 'json', 'yaml']), default='table', help='Output format')
+@click.option('--filter-framework', help='Filter templates by framework')
+@click.option('--format', type=click.Choice(['table', 'json']), default='table', help='Output format')
 def template(action_list, action_info, framework, template, filter_framework, format):
-    """Manage project templates - list available templates or get detailed information"""
+    """Manage project templates"""
     
     if not action_list and not action_info:
-        click.echo("❌ Please specify either --list or --info")
-        click.echo("Usage examples:")
-        click.echo("  runagent template --list")
-        click.echo("  runagent template --info --framework langchain --template basic")
+        console.print("❌ Please specify either [cyan]--list[/cyan] or [cyan]--info[/cyan]")
         raise click.ClickException("No action specified")
     
-    if action_list and action_info:
-        click.echo("❌ Please specify only one action: --list or --info")
-        raise click.ClickException("Multiple actions specified")
-    
-    client = RunAgentClient(cli_mode=True)
-    
-    if action_list:
-        _handle_list_templates(client, filter_framework, format)
-    elif action_info:
-        _handle_template_info(client, framework, template)
-
-
-def _handle_list_templates(client, filter_framework, format):
-    """Handle the --list action"""
     try:
-        available_templates = client.list_templates()
-        
-        if not available_templates:
-            click.echo("❌ No templates available")
-            return
-        
-        # Apply framework filter if specified
-        if filter_framework:
-            if filter_framework not in available_templates:
-                click.echo(f"❌ Framework '{filter_framework}' not found")
-                click.echo(f"Available frameworks: {', '.join(available_templates.keys())}")
-                return
-            available_templates = {filter_framework: available_templates[filter_framework]}
+        sdk = RunAgent()
         
-        # Output in different formats
-        if format == 'json':
-            import json
-            click.echo(json.dumps(available_templates, indent=2))
-        elif format == 'yaml':
-            try:
-                import yaml
-                click.echo(yaml.dump(available_templates, default_flow_style=False))
-            except ImportError:
-                click.echo("❌ PyYAML not installed. Using JSON format instead.")
-                import json
-                click.echo(json.dumps(available_templates, indent=2))
-        else:  # table format (default)
-            click.secho("📋 Available Templates:", fg='cyan', bold=True)
-            
-            for framework_name, templates in available_templates.items():
-                click.secho(f"\n🎯 {framework_name}:", fg='blue', bold=True)
-                for tmpl in templates:
-                    click.echo(f"  - {tmpl}")
-            
-            click.echo(f"\n💡 Use 'runagent template --info --framework <framework> --template <template>' for details")
+        if action_list:
+            templates = sdk.list_templates(framework=filter_framework)
             
-    except Exception as e:
-        click.echo(f"❌ Error listing templates: {str(e)}")
-
-
-def _handle_template_info(client, framework, template):
-    """Handle the --info action"""
-    if not framework or not template:
-        click.echo("❌ Both --framework and --template are required for --info")
-        click.echo("Usage: runagent template --info --framework <framework> --template <template>")
-        raise click.ClickException("Missing required parameters")
-    
-    try:
-        from runagent.constants import TEMPLATE_REPO_URL, TEMPLATE_BRANCH, TEMPLATE_PREPATH
-        from runagent.client.template_downloader import TemplateDownloader
-        
-        downloader = TemplateDownloader(TEMPLATE_REPO_URL, TEMPLATE_BRANCH)
-        info = downloader.get_template_info(TEMPLATE_PREPATH, framework, template)
-        
-        if info:
-            click.secho(f"📋 Template Information: {framework}/{template}", fg='cyan', bold=True)
-            click.echo(f"Framework: {info['framework']}")
-            click.echo(f"Template: {info['template']}")
-            
-            if 'metadata' in info:
-                metadata = info['metadata']
-                if 'description' in metadata:
-                    click.echo(f"Description: {metadata['description']}")
-                if 'requirements' in metadata:
-                    click.echo(f"Requirements: {', '.join(metadata['requirements'])}")
-                if 'version' in metadata:
-                    click.echo(f"Version: {metadata['version']}")
-                if 'author' in metadata:
-                    click.echo(f"Author: {metadata['author']}")
-            
-            click.echo(f"\n📁 Structure:")
-            click.echo(f"Files: {', '.join(info['files'])}")
-            if info['directories']:
-                click.echo(f"Directories: {', '.join(info['directories'])}")
-            
-            if 'readme' in info:
-                click.echo(f"\n📖 README:")
-                click.echo("-" * 50)
-                click.echo(info['readme'])
-                click.echo("-" * 50)
-            
-            click.echo(f"\n🚀 To use this template:")
-            click.echo(f"runagent init --framework {framework} --template {template}")
+            if format == 'json':
+                console.print(json.dumps(templates, indent=2))
+            else:
+                console.print("📋 [bold cyan]Available Templates:[/bold cyan]")
+                for framework_name, template_list in templates.items():
+                    console.print(f"\n🎯 [bold blue]{framework_name}:[/bold blue]")
+                    for tmpl in template_list:
+                        console.print(f"  • {tmpl}")
+                
+                console.print(f"\n💡 Use [cyan]'runagent template --info --framework <fw> --template <tmpl>'[/cyan] for details")
+        
+        elif action_info:
+            if not framework or not template:
+                console.print("❌ Both [cyan]--framework[/cyan] and [cyan]--template[/cyan] are required for --info")
+                raise click.ClickException("Missing required parameters")
             
-        else:
-            click.echo(f"❌ Template '{framework}/{template}' not found")
+            template_info = sdk.get_template_info(framework, template)
             
-            # Suggest available templates for the framework
-            try:
-                available_templates = client.list_templates()
-                if framework in available_templates:
-                    click.echo(f"Available templates for {framework}: {', '.join(available_templates[framework])}")
+            if template_info:
+                console.print(f"📋 [bold cyan]Template: {framework}/{template}[/bold cyan]")
+                console.print(f"Framework: [magenta]{template_info['framework']}[/magenta]")
+                console.print(f"Template: [yellow]{template_info['template']}[/yellow]")
+                
+                if 'metadata' in template_info:
+                    metadata = template_info['metadata']
+                    if 'description' in metadata:
+                        console.print(f"Description: {metadata['description']}")
+                    if 'requirements' in metadata:
+                        console.print(f"Requirements: {', '.join(metadata['requirements'])}")
+                
+                console.print(f"\n📁 [bold]Structure:[/bold]")
+                console.print(f"Files: {', '.join(template_info['files'])}")
+                if template_info.get('directories'):
+                    console.print(f"Directories: {', '.join(template_info['directories'])}")
+                
+                if 'readme' in template_info:
+                    console.print(f"\n📖 [bold]README:[/bold]")
+                    console.print("-" * 50)
+                    console.print(template_info['readme'][:500] + "..." if len(template_info['readme']) > 500 else template_info['readme'])
+                    console.print("-" * 50)
+                
+                console.print(f"\n🚀 [bold]To use this template:[/bold]")
+                console.print(f"[cyan]runagent init --framework {framework} --template {template}[/cyan]")
+            else:
+                console.print(f"❌ Template [yellow]{framework}/{template}[/yellow] not found")
+                
+                # Show available templates
+                templates = sdk.list_templates()
+                if framework in templates:
+                    console.print(f"Available templates for {framework}: {', '.join(templates[framework])}")
                 else:
-                    click.echo(f"Available frameworks: {', '.join(available_templates.keys())}")
-            except:
-                pass
-            
+                    console.print(f"Available frameworks: {', '.join(templates.keys())}")
+    
     except Exception as e:
-        click.echo(f"❌ Error getting template info: {str(e)}")
-
+        console.print(f"❌ [red]Template error:[/red] {e}")
+        raise click.ClickException("Template operation failed")
 
-# Add these new commands to your existing runagent/cli/commands.py file
-
-import click
-import json
-from pathlib import Path
-from rich.console import Console
-
-console = Console()
 
 @click.command()
-@click.option('--folder', required=True, help='Folder containing agent files to deploy locally')
+@click.option('--folder', required=True, help='Folder containing agent files')
 @click.option('--framework', help='Framework type (auto-detected if not specified)')
 @click.option('--replace', help='Agent ID to replace (for capacity management)')
 def deploy_local(folder, framework, replace):
-    """Deploy agent locally for testing (max 5 agents)"""
+    """Deploy agent locally for testing"""
+    
     try:
-        from runagent.client.local_client import LocalClient
+        sdk = RunAgent()
         
+        # Validate folder
         if not Path(folder).exists():
             raise click.ClickException(f"Folder not found: {folder}")
         
-        # Detect framework if not provided
-        if not framework:
-            framework = _detect_framework(folder)
-        
-        local_client = LocalClient()
+        console.print(f"🚀 [bold]Deploying agent locally...[/bold]")
+        console.print(f"📁 Source: [cyan]{folder}[/cyan]")
         
-        # Check capacity if not replacing
-        if not replace:
-            capacity_info = local_client.get_capacity_info()
-            if capacity_info.get('is_full'):
-                console.print(f"\n⚠️ [yellow]Database at full capacity ({capacity_info.get('current_count')}/5 agents)[/yellow]")
-                console.print("💡 Available options:")
-                
-                agents = capacity_info.get('agents', [])
-                for i, agent in enumerate(agents):
-                    console.print(f"   {i+1}. Replace: [cyan]{agent['agent_id']}[/cyan] (deployed: {agent['deployed_at']})")
-                
-                oldest_agent = capacity_info.get('oldest_agent')
-                if oldest_agent:
-                    console.print(f"\n💡 Suggested command:")
-                    console.print(f"   [cyan]runagent deploy-local --folder {folder} --replace {oldest_agent['agent_id']}[/cyan]")
-                
-                raise click.ClickException("Database at capacity. Use --replace to replace an existing agent.")
-        
-        result = local_client.deploy_agent(
-            folder_path=folder,
-            metadata={'framework': framework},
+        # Deploy agent
+        result = sdk.deploy_local(
+            folder=folder,
+            framework=framework,
             replace_agent_id=replace
         )
         
         if result.get('success'):
-            click.echo(f"\n✅ {result.get('message', 'Deployment successful')}")
-            click.echo(f"🆔 Agent ID: {result.get('agent_id')}")
+            agent_id = result['agent_id']
+            console.print(f"\n✅ [green]Local deployment successful![/green]")
+            console.print(f"🆔 Agent ID: [bold magenta]{agent_id}[/bold magenta]")
+            console.print(f"🌐 Endpoint: [link]{result.get('endpoint')}[/link]")
             
             if replace:
-                click.echo(f"🔄 Replaced agent: {replace}")
+                console.print(f"🔄 Replaced agent: [yellow]{replace}[/yellow]")
+            
+            # Show capacity info
+            capacity = sdk.get_local_capacity()
+            console.print(f"📊 Capacity: [cyan]{capacity.get('current_count', 1)}/5[/cyan] slots used")
+            
+            console.print(f"\n💡 [bold]Next steps:[/bold]")
+            console.print(f"  • Start server: [cyan]runagent serve[/cyan]")
+            console.print(f"  • Test agent: [cyan]runagent run --id {agent_id} --local[/cyan]")
         else:
             error_code = result.get('error_code')
             if error_code == 'DATABASE_FULL':
                 capacity_info = result.get('capacity_info', {})
+                console.print(f"\n❌ [red]Database at full capacity![/red]")
+                console.print(f"📊 Current: {capacity_info.get('current_count', 0)}/5 agents")
+                
                 oldest_agent = capacity_info.get('oldest_agent', {}).get('agent_id')
-                suggestion = result.get('suggestion', '')
+                if oldest_agent:
+                    console.print(f"\n💡 [yellow]Suggested command:[/yellow]")
+                    console.print(f"[cyan]runagent deploy-local --folder {folder} --replace {oldest_agent}[/cyan]")
                 
-                console.print(f"\n💡 [yellow]Suggestion:[/yellow] {suggestion}")
                 raise click.ClickException(result.get('error'))
             else:
                 raise click.ClickException(result.get('error'))
-            
+    
+    except ValidationError as e:
+        console.print(f"❌ [red]Validation error:[/red] {e}")
+        raise click.ClickException("Deployment failed")
     except Exception as e:
-        raise click.ClickException(str(e))
+        console.print(f"❌ [red]Deployment error:[/red] {e}")
+        raise click.ClickException("Deployment failed")
 
 
 @click.command()
-@click.option('--folder', required=True, help='Folder containing agent files to upload')
+@click.option('--folder', required=True, help='Folder containing agent files')
 @click.option('--framework', help='Framework type (auto-detected if not specified)')
 def upload(folder, framework):
     """Upload agent to remote server"""
+    
     try:
-        from runagent.client.rest_client import RestClient
+        sdk = RunAgent()
+        
+        # Check authentication
+        if not sdk.is_configured():
+            console.print("❌ [red]Not authenticated.[/red] Run [cyan]'runagent setup --api-key <key>'[/cyan] first")
+            raise click.ClickException("Authentication required")
         
+        # Validate folder
         if not Path(folder).exists():
             raise click.ClickException(f"Folder not found: {folder}")
         
-        # Detect framework if not provided
-        if not framework:
-            framework = _detect_framework(folder)
+        console.print(f"📤 [bold]Uploading agent...[/bold]")
+        console.print(f"📁 Source: [cyan]{folder}[/cyan]")
         
-        rest_client = RestClient()
-        result = rest_client.upload_agent(
-            folder_path=folder,
-            metadata={'framework': framework}
-        )
+        # Upload agent
+        result = sdk.upload_agent(folder=folder, framework=framework)
         
         if result.get('success'):
-            click.echo(f"\n✅ {result.get('message')}")
-            click.echo(f"🆔 Agent ID: {result.get('agent_id')}")
+            agent_id = result['agent_id']
+            console.print(f"\n✅ [green]Upload successful![/green]")
+            console.print(f"🆔 Agent ID: [bold magenta]{agent_id}[/bold magenta]")
+            console.print(f"\n💡 [bold]Next step:[/bold]")
+            console.print(f"[cyan]runagent start --id {agent_id}[/cyan]")
         else:
-            raise click.ClickException(f"Upload failed: {result.get('error')}")
-            
+            raise click.ClickException(result.get('error'))
+    
+    except AuthenticationError as e:
+        console.print(f"❌ [red]Authentication error:[/red] {e}")
+        raise click.ClickException("Upload failed")
     except Exception as e:
-        raise click.ClickException(str(e))
+        console.print(f"❌ [red]Upload error:[/red] {e}")
+        raise click.ClickException("Upload failed")
 
 
 @click.command()
@@ -295,10 +371,16 @@ def upload(folder, framework):
 @click.option('--config', help='JSON configuration for deployment')
 def start(agent_id, config):
     """Start an uploaded agent on remote server"""
+    
     try:
-        from runagent.client.rest_client import RestClient
+        sdk = RunAgent()
+        
+        # Check authentication
+        if not sdk.is_configured():
+            console.print("❌ [red]Not authenticated.[/red] Run [cyan]'runagent setup --api-key <key>'[/cyan] first")
+            raise click.ClickException("Authentication required")
         
-        # Parse config if provided
+        # Parse config
         config_dict = {}
         if config:
             try:
@@ -306,17 +388,24 @@ def start(agent_id, config):
             except json.JSONDecodeError:
                 raise click.ClickException("Invalid JSON in config parameter")
         
-        rest_client = RestClient()
-        result = rest_client.start_agent(agent_id, config_dict)
+        console.print(f"🚀 [bold]Starting agent...[/bold]")
+        console.print(f"🆔 Agent ID: [magenta]{agent_id}[/magenta]")
+        
+        # Start agent
+        result = sdk.start_remote_agent(agent_id, config_dict)
         
         if result.get('success'):
-            click.echo(f"\n✅ Agent started successfully!")
-            click.echo(f"🌐 Endpoint: {result.get('endpoint')}")
+            console.print(f"\n✅ [green]Agent started successfully![/green]")
+            console.print(f"🌐 Endpoint: [link]{result.get('endpoint')}[/link]")
         else:
-            raise click.ClickException(f"Start failed: {result.get('error')}")
-            
+            raise click.ClickException(result.get('error'))
+    
+    except AuthenticationError as e:
+        console.print(f"❌ [red]Authentication error:[/red] {e}")
+        raise click.ClickException("Start failed")
     except Exception as e:
-        raise click.ClickException(str(e))
+        console.print(f"❌ [red]Start error:[/red] {e}")
+        raise click.ClickException("Start failed")
 
 
 @click.command()
@@ -327,121 +416,110 @@ def start(agent_id, config):
 @click.option('--config', help='JSON configuration for deployment')
 def deploy(folder, agent_id, local, framework, config):
     """Deploy agent (upload + start) or deploy locally"""
+    
     try:
+        sdk = RunAgent()
+        
         if local:
             # Local deployment
             if not folder:
                 raise click.ClickException("--folder is required for local deployment")
             
+            # Use deploy_local command logic
+            ctx = click.get_current_context()
+            ctx.invoke(deploy_local, folder=folder, framework=framework)
+            return
+        
+        # Remote deployment
+        if not sdk.is_configured():
+            console.print("❌ [red]Not authenticated.[/red] Run [cyan]'runagent setup --api-key <key>'[/cyan] first")
+            raise click.ClickException("Authentication required")
+        
+        # Parse config
+        config_dict = {}
+        if config:
+            try:
+                config_dict = json.loads(config)
+            except json.JSONDecodeError:
+                raise click.ClickException("Invalid JSON in config parameter")
+        
+        if folder:
+            # Full deployment (upload + start)
             if not Path(folder).exists():
                 raise click.ClickException(f"Folder not found: {folder}")
             
-            # Detect framework if not provided
-            if not framework:
-                framework = _detect_framework(folder)
+            console.print(f"🎯 [bold]Full deployment (upload + start)...[/bold]")
+            console.print(f"📁 Source: [cyan]{folder}[/cyan]")
             
-            from runagent.client.local_client import LocalClient
-            local_client = LocalClient()
-            result = local_client.deploy_agent(
-                folder_path=folder,
-                metadata={'framework': framework}
+            result = sdk.deploy_remote(
+                folder=folder,
+                framework=framework,
+                config=config_dict
             )
             
             if result.get('success'):
-                click.echo(f"\n✅ {result.get('message')}")
-                click.echo(f"🆔 Agent ID: {result.get('agent_id')}")
+                console.print(f"\n✅ [green]Full deployment successful![/green]")
+                console.print(f"🆔 Agent ID: [bold magenta]{result.get('agent_id')}[/bold magenta]")
+                console.print(f"🌐 Endpoint: [link]{result.get('endpoint')}[/link]")
             else:
-                raise click.ClickException(f"Local deployment failed: {result.get('error')}")
+                raise click.ClickException(result.get('error'))
+        
+        elif agent_id:
+            # Start existing agent
+            ctx = click.get_current_context()
+            ctx.invoke(start, agent_id=agent_id, config=config)
         
         else:
-            # Remote deployment
-            from runagent.client.rest_client import RestClient
-            rest_client = RestClient()
-            
-            if folder:
-                # Upload + Start
-                if not Path(folder).exists():
-                    raise click.ClickException(f"Folder not found: {folder}")
-                
-                # Detect framework if not provided
-                if not framework:
-                    framework = _detect_framework(folder)
-                
-                # Parse config if provided
-                config_dict = {}
-                if config:
-                    try:
-                        config_dict = json.loads(config)
-                    except json.JSONDecodeError:
-                        raise click.ClickException("Invalid JSON in config parameter")
-                
-                result = rest_client.deploy_agent(
-                    folder_path=folder,
-                    metadata={'framework': framework}
-                )
-                
-                if result.get('success'):
-                    click.echo(f"\n✅ {result.get('message')}")
-                    click.echo(f"🆔 Agent ID: {result.get('agent_id')}")
-                    click.echo(f"🌐 Endpoint: {result.get('endpoint')}")
-                else:
-                    raise click.ClickException(f"Deployment failed: {result.get('error')}")
-            
-            elif agent_id:
-                # Start existing agent
-                config_dict = {}
-                if config:
-                    try:
-                        config_dict = json.loads(config)
-                    except json.JSONDecodeError:
-                        raise click.ClickException("Invalid JSON in config parameter")
-                
-                result = rest_client.start_agent(agent_id, config_dict)
-                
-                if result.get('success'):
-                    click.echo(f"\n✅ Agent started successfully!")
-                    click.echo(f"🌐 Endpoint: {result.get('endpoint')}")
-                else:
-                    raise click.ClickException(f"Start failed: {result.get('error')}")
-            
-            else:
-                raise click.ClickException("Either --folder (for upload+start) or --id (for start only) is required")
-            
+            raise click.ClickException("Either --folder (for upload+start) or --id (for start only) is required")
+    
     except Exception as e:
-        raise click.ClickException(str(e))
+        console.print(f"❌ [red]Deployment error:[/red] {e}")
+        raise click.ClickException("Deployment failed")
 
 
 @click.command()
-@click.option('--port', default=8450, help='Port to run the local server on')
-@click.option('--host', default='127.0.0.1', help='Host to bind the server to')
+@click.option('--port', default=8450, help='Port to run server on')
+@click.option('--host', default='127.0.0.1', help='Host to bind server to')
 @click.option('--debug', is_flag=True, help='Run server in debug mode')
 def serve(port, host, debug):
     """Start local FastAPI server for testing deployed agents"""
+    
     try:
-        from runagent.server.local_server import LocalServer
+        sdk = RunAgent()
         
-        console.print("⚡ Starting FastAPI server...")
-        server = LocalServer(port=port, host=host)
-        server.start(debug=debug)
+        console.print(f"⚡ [bold]Starting local server...[/bold]")
+        console.print(f"🌐 URL: [bold blue]http://{host}:{port}[/bold blue]")
+        console.print(f"📖 Docs: [link]http://{host}:{port}/docs[/link]")
         
+        # Start server (this will block)
+        sdk.start_local_server(port=port, host=host, debug=debug)
+    
     except KeyboardInterrupt:
         console.print("\n🛑 [yellow]Server stopped by user[/yellow]")
     except Exception as e:
-        raise click.ClickException(str(e))
+        console.print(f"❌ [red]Server error:[/red] {e}")
+        raise click.ClickException("Server failed to start")
 
 
 @click.command()
 @click.option('--id', 'agent_id', required=True, help='Agent ID to run')
 @click.option('--input', 'input_file', help='Path to input JSON file')
-@click.option('--message', '-m', help='Simple message to send to the agent')
+@click.option('--message', '-m', help='Simple message to send to agent')
 @click.option('--local', is_flag=True, help='Run agent locally')
+@click.option('--direct', is_flag=True, help='Run agent directly (bypass HTTP server)')
 @click.option('--timeout', default=300, help='Maximum wait time in seconds')
-def run(agent_id, input_file, message, local, timeout):
+def run(agent_id, input_file, message, local, direct, timeout):
     """Run a deployed agent"""
+    
     try:
-        # Prepare input data
-        input_data = {}
+        sdk = RunAgent()
+        
+        # Check authentication for remote runs
+        if not local and not sdk.is_configured():
+            console.print("❌ [red]Not authenticated.[/red] Run [cyan]'runagent setup --api-key <key>'[/cyan] first")
+            raise click.ClickException("Authentication required for remote runs")
         
+        # Prepare input
         if input_file:
             if not Path(input_file).exists():
                 raise click.ClickException(f"Input file not found: {input_file}")
@@ -449,133 +527,152 @@ def run(agent_id, input_file, message, local, timeout):
             with open(input_file, 'r') as f:
                 try:
                     input_data = json.load(f)
+                    messages = input_data.get('messages', [])
                 except json.JSONDecodeError:
                     raise click.ClickException(f"Invalid JSON in input file: {input_file}")
         
         elif message:
-            input_data = {
-                "messages": [
-                    {
-                        "role": "user",
-                        "content": message
-                    }
-                ]
-            }
+            messages = [{"role": "user", "content": message}]
+        
         else:
             # Interactive mode
-            click.echo("Enter your message (press Enter twice to submit):")
+            console.print("Enter your message (press Enter twice to submit):")
             lines = []
             while True:
-                line = input()
-                if line == "" and lines:
-                    break
-                lines.append(line)
+                try:
+                    line = input()
+                    if line == "" and lines:
+                        break
+                    lines.append(line)
+                except (EOFError, KeyboardInterrupt):
+                    console.print("\n❌ Input cancelled")
+                    return
             
             message_text = '\n'.join(lines)
-            input_data = {
-                "messages": [
-                    {
-                        "role": "user",
-                        "content": message_text
-                    }
-                ]
-            }
+            messages = [{"role": "user", "content": message_text}]
         
+        # Determine execution method
         if local:
-            # Run locally
-            from runagent.client.local_client import LocalClient
-            
-            console.print(f"🏠 Running agent locally: [cyan]{agent_id}[/cyan]")
-            
-            local_client = LocalClient()
-            result = local_client.run_agent(agent_id, input_data)
-            
+            if direct:
+                console.print(f"🏃 [bold]Running agent directly (bypass server)...[/bold]")
+                execution_method = "Direct"
+                
+                # Use direct execution method
+                input_data = {"messages": messages}
+                result = sdk.local.run_agent_direct(agent_id, input_data)
+            else:
+                console.print(f"🏃 [bold]Running agent via local server...[/bold]")
+                execution_method = "Local Server"
+                
+                # Check if server is running first
+                server_status = sdk.local.check_server_status()
+                if not server_status.get('running'):
+                    console.print(f"❌ [red]Local server not running![/red]")
+                    console.print(f"💡 Start server with: [cyan]runagent serve[/cyan]")
+                    console.print(f"💡 Or use direct execution: [cyan]runagent run --id {agent_id} --local --direct[/cyan]")
+                    raise click.ClickException("Local server not available")
+                
+                console.print(f"✅ [green]Server is running at {server_status['url']}[/green]")
+                
+                # Run via HTTP server
+                result = sdk.run_agent(
+                    agent_id=agent_id,
+                    messages=messages,
+                    local=True
+                )
         else:
-            # Run remotely
-            import requests
-            import time
-            
-            # Get deployment info
-            deployments_dir = Path.cwd() / ".deployments"
-            info_file = deployments_dir / f"{agent_id}.json"
-            
-            if not info_file.exists():
-                raise click.ClickException(f"No deployment info found for agent {agent_id}")
+            console.print(f"🏃 [bold]Running agent remotely...[/bold]")
+            execution_method = "Remote"
             
-            with open(info_file, 'r') as f:
-                deployment_info = json.load(f)
+            # Run remotely
+            result = sdk.run_agent(
+                agent_id=agent_id,
+                messages=messages,
+                local=False
+            )
+        
+        console.print(f"🆔 Agent: [magenta]{agent_id}[/magenta]")
+        console.print(f"📍 Method: [cyan]{execution_method}[/cyan]")
+        
+        # Run the agent
+        import time
+        start_time = time.time()
+        execution_time = time.time() - start_time
+        
+        # Display results
+        if result.get('success'):
+            console.print(f"\n✅ [green]Agent execution completed![/green]")
             
-            endpoint = deployment_info.get('endpoint')
-            if not endpoint:
-                raise click.ClickException(f"No endpoint found for agent {agent_id}")
+            agent_result = result.get('result', {})
+            content = agent_result.get('content', '')
             
-            console.print(f"🌐 Running agent remotely: [cyan]{agent_id}[/cyan]")
-            console.print(f"📡 Endpoint: [blue]{endpoint}[/blue]")
+            console.print(f"\n📄 [bold]Response:[/bold]")
+            console.print(content)
             
-            start_time = time.time()
-            response = requests.post(endpoint, json=input_data, timeout=timeout)
-            execution_time = time.time() - start_time
+            # Show metadata
+            metadata = agent_result.get('metadata', {})
+            if metadata:
+                console.print(f"\n📊 [bold]Metadata:[/bold]")
+                for key, value in metadata.items():
+                    if key != 'execution_time':  # Skip since we show our own
+                        console.print(f"  • {key}: [cyan]{value}[/cyan]")
             
-            if response.status_code == 200:
-                result = response.json()
+            # Show execution time from result or calculate our own
+            if 'execution_time' in result:
+                total_time = result['execution_time']
             else:
-                raise click.ClickException(f"Agent execution failed: HTTP {response.status_code}")
-        
-        # Display result
-        if result.get('success'):
-            console.print("\n✅ [bold green]Agent execution completed![/bold green]")
+                total_time = execution_time
             
-            if 'result' in result and result['result']:
-                agent_result = result['result']
-                content = agent_result.get('content', '')
-                
-                console.print(f"\n📄 [bold]Result:[/bold]")
-                console.print(content)
-                
-                # Show metadata if available
-                if 'metadata' in agent_result:
-                    metadata = agent_result['metadata']
-                    console.print(f"\n📊 [bold]Metadata:[/bold]")
-                    for key, value in metadata.items():
-                        console.print(f"  • {key}: {value}")
-            
-            if not local:
-                console.print(f"\n⏱️ Total time: {execution_time:.2f}s")
+            console.print(f"\n⏱️ Total time: [yellow]{total_time:.2f}s[/yellow]")
         else:
             error_msg = result.get('error', 'Unknown error')
-            raise click.ClickException(f"Agent execution failed: {error_msg}")
+            console.print(f"\n❌ [red]Agent execution failed:[/red] {error_msg}")
+            
+            # Show suggestions based on error type
+            if 'Server not reachable' in error_msg or 'Connection' in error_msg:
+                console.print(f"💡 [yellow]Suggestion:[/yellow] Start the server with [cyan]runagent serve[/cyan]")
+                console.print(f"💡 [yellow]Alternative:[/yellow] Use direct execution with [cyan]--direct[/cyan] flag")
             
+            raise click.ClickException("Agent run failed")
+    
+    except ConnectionError as e:
+        console.print(f"❌ [red]Connection error:[/red] {e}")
+        console.print(f"💡 [yellow]Suggestion:[/yellow] Start the server with [cyan]runagent serve[/cyan]")
+        raise click.ClickException("Connection failed")
     except Exception as e:
-        raise click.ClickException(str(e))
+        console.print(f"❌ [red]Run error:[/red] {e}")
+        raise click.ClickException("Agent run failed")
+
 
 
 @click.command()
-@click.option('--cleanup-days', type=int, help='Clean up run records older than N days')
+@click.option('--cleanup-days', type=int, help='Clean up records older than N days')
 @click.option('--agent-id', help='Show detailed info for specific agent')
 @click.option('--capacity', is_flag=True, help='Show detailed capacity information')
 def db_status(cleanup_days, agent_id, capacity):
     """Show local database status and statistics"""
+    
     try:
-        from runagent.client.local_client import LocalClient
-        
-        local_client = LocalClient()
+        sdk = RunAgent()
         
         if capacity:
             # Show detailed capacity info
-            capacity_info = local_client.get_capacity_info()
+            capacity_info = sdk.get_local_capacity()
             
             console.print(f"\n📊 [bold]Database Capacity Information[/bold]")
-            console.print(f"Current: {capacity_info.get('current_count', 0)}/5 agents")
-            console.print(f"Remaining slots: {capacity_info.get('remaining_slots', 0)}")
-            console.print(f"Status: {'🔴 FULL' if capacity_info.get('is_full') else '🟢 Available'}")
+            console.print(f"Current: [cyan]{capacity_info.get('current_count', 0)}/5[/cyan] agents")
+            console.print(f"Remaining slots: [green]{capacity_info.get('remaining_slots', 0)}[/green]")
+            
+            status = "🔴 FULL" if capacity_info.get('is_full') else "🟢 Available"
+            console.print(f"Status: {status}")
             
             agents = capacity_info.get('agents', [])
             if agents:
                 console.print(f"\n📋 [bold]Deployed Agents (by age):[/bold]")
                 for i, agent in enumerate(agents):
                     status_icon = "🟢" if agent['status'] == 'deployed' else "🔴" if agent['status'] == 'error' else "🟡"
-                    age_label = "oldest" if i == 0 else "newest" if i == len(agents)-1 else ""
-                    console.print(f"  {i+1}. {status_icon} {agent['agent_id']} ({agent['framework']}) - {agent['deployed_at']} {age_label}")
+                    age_label = " (oldest)" if i == 0 else " (newest)" if i == len(agents)-1 else ""
+                    console.print(f"  {i+1}. {status_icon} [magenta]{agent['agent_id']}[/magenta] ({agent['framework']}) - {agent['deployed_at']}{age_label}")
             
             if capacity_info.get('is_full'):
                 oldest = capacity_info.get('oldest_agent', {})
@@ -586,115 +683,78 @@ def db_status(cleanup_days, agent_id, capacity):
         
         if agent_id:
             # Show specific agent info
-            result = local_client.get_agent_info(agent_id)
+            result = sdk.get_agent_info(agent_id, local=True)
+            
             if result.get('success'):
                 agent_info = result['agent_info']
                 console.print(f"\n📊 [bold]Agent: {agent_id}[/bold]")
-                console.print(f"Status: {agent_info['status']}")
-                console.print(f"Framework: {agent_info['framework']}")
-                console.print(f"Deployed: {agent_info['deployed_at']}")
-                console.print(f"Source Path: {agent_info['folder_path']}")
-                console.print(f"Deployment Path: {agent_info['deployment_path']}")
-                console.print(f"Files Exist: {'✅' if agent_info.get('deployment_exists') else '❌'}")
-                console.print(f"Source Exists: {'✅' if agent_info.get('source_exists') else '❌'}")
+                console.print(f"Status: [cyan]{agent_info['status']}[/cyan]")
+                console.print(f"Framework: [magenta]{agent_info['framework']}[/magenta]")
+                console.print(f"Deployed: [yellow]{agent_info['deployed_at']}[/yellow]")
+                console.print(f"Source Path: [blue]{agent_info['folder_path']}[/blue]")
+                console.print(f"Deployment Path: [blue]{agent_info['deployment_path']}[/blue]")
+                
+                exists_status = "✅" if agent_info.get('deployment_exists') else "❌"
+                source_status = "✅" if agent_info.get('source_exists') else "❌"
+                console.print(f"Files Exist: {exists_status}")
+                console.print(f"Source Exists: {source_status}")
                 
                 stats = agent_info.get('stats', {})
                 if stats:
                     console.print(f"\n📈 [bold]Statistics:[/bold]")
-                    console.print(f"Total Runs: {stats.get('total_runs', 0)}")
-                    console.print(f"Success Rate: {stats.get('success_rate', 0)}%")
-                    console.print(f"Last Run: {stats.get('last_run', 'Never')}")
-                    console.print(f"Avg Execution Time: {stats.get('avg_execution_time', 'N/A')}s")
-                
-                recent_runs = agent_info.get('recent_runs', [])
-                if recent_runs:
-                    console.print(f"\n📝 [bold]Recent Runs:[/bold]")
-                    for run in recent_runs[:3]:
-                        status = "✅" if run['success'] else "❌"
-                        console.print(f"  {status} {run['started_at']} ({run.get('execution_time', 'N/A')}s)")
+                    console.print(f"Total Runs: [cyan]{stats.get('total_runs', 0)}[/cyan]")
+                    console.print(f"Success Rate: [green]{stats.get('success_rate', 0)}%[/green]")
+                    console.print(f"Last Run: [yellow]{stats.get('last_run', 'Never')}[/yellow]")
+                    avg_time = stats.get('avg_execution_time')
+                    if avg_time:
+                        console.print(f"Avg Execution Time: [cyan]{avg_time}s[/cyan]")
             else:
-                console.print(f"❌ {result.get('error')}")
-        else:
-            # Show database stats
-            stats = local_client.get_database_stats()
-            capacity_info = local_client.get_capacity_info()
-            
-            if stats:
-                console.print("\n📊 [bold]Local Database Status[/bold]")
-                console.print(f"Capacity: {capacity_info.get('current_count', 0)}/5 agents ({'FULL' if capacity_info.get('is_full') else 'OK'})")
-                console.print(f"Total Runs: {stats.get('total_runs', 0)}")
-                console.print(f"Database Size: {stats.get('database_size_mb', 0)} MB")
-                console.print(f"Database Path: {stats.get('database_path', 'Unknown')}")
-                
-                status_counts = stats.get('agent_status_counts', {})
-                if status_counts:
-                    console.print("\n📈 [bold]Agent Status Breakdown:[/bold]")
-                    for status, count in status_counts.items():
-                        console.print(f"  {status}: {count}")
-                
-                # List agents
-                agents_result = local_client.list_local_agents()
-                if agents_result.get('success'):
-                    agents = agents_result.get('agents', [])
-                    if agents:
-                        console.print(f"\n📋 [bold]Deployed Agents:[/bold]")
-                        for agent in agents:
-                            status_icon = "🟢" if agent['status'] == 'deployed' else "🔴" if agent['status'] == 'error' else "🟡"
-                            exists_icon = "📁" if agent.get('exists') else "❌"
-                            console.print(f"  {status_icon} {exists_icon} {agent['agent_id']} ({agent['framework']}) - {agent['status']}")
-                        
-                        console.print(f"\n💡 Use --agent-id <id> for detailed info")
-                        console.print(f"💡 Use --capacity for capacity management info")
+                console.print(f"❌ [red]{result.get('error')}[/red]")
+            return
+        
+        # Show general database stats
+        stats = sdk.get_local_stats()
+        capacity_info = sdk.get_local_capacity()
+        
+        console.print("\n📊 [bold]Local Database Status[/bold]")
+        
+        current_count = capacity_info.get('current_count', 0)
+        is_full = capacity_info.get('is_full', False)
+        status = "FULL" if is_full else "OK"
+        console.print(f"Capacity: [cyan]{current_count}/5[/cyan] agents ([red]{status}[/red]" if is_full else f"Capacity: [cyan]{current_count}/5[/cyan] agents ([green]{status}[/green])")
+        
+        console.print(f"Total Runs: [cyan]{stats.get('total_runs', 0)}[/cyan]")
+        console.print(f"Database Size: [yellow]{stats.get('database_size_mb', 0)} MB[/yellow]")
+        console.print(f"Database Path: [blue]{stats.get('database_path', 'Unknown')}[/blue]")
+        
+        # Show agent status breakdown
+        status_counts = stats.get('agent_status_counts', {})
+        if status_counts:
+            console.print("\n📈 [bold]Agent Status Breakdown:[/bold]")
+            for status, count in status_counts.items():
+                console.print(f"  [cyan]{status}[/cyan]: {count}")
+        
+        # List agents
+        agents = sdk.list_local_agents()
+        if agents:
+            console.print(f"\n📋 [bold]Deployed Agents:[/bold]")
+            for agent in agents:
+                status_icon = "🟢" if agent['status'] == 'deployed' else "🔴" if agent['status'] == 'error' else "🟡"
+                exists_icon = "📁" if agent.get('exists') else "❌"
+                console.print(f"  {status_icon} {exists_icon} [magenta]{agent['agent_id']}[/magenta] ({agent['framework']}) - {agent['status']}")
+            
+            console.print(f"\n💡 Use [cyan]--agent-id <id>[/cyan] for detailed info")
+            console.print(f"💡 Use [cyan]--capacity[/cyan] for capacity management info")
         
         # Cleanup if requested
         if cleanup_days:
-            console.print(f"\n🧹 Cleaning up run records older than {cleanup_days} days...")
-            cleanup_result = local_client.cleanup_old_runs(cleanup_days)
+            console.print(f"\n🧹 Cleaning up records older than {cleanup_days} days...")
+            cleanup_result = sdk.cleanup_local_database(cleanup_days)
             if cleanup_result.get('success'):
-                console.print(f"✅ {cleanup_result.get('message')}")
+                console.print(f"✅ [green]{cleanup_result.get('message')}[/green]")
             else:
-                console.print(f"❌ {cleanup_result.get('error')}")
-        
-    except Exception as e:
-        raise click.ClickException(str(e))
-
-
-def _detect_framework(folder_path: str) -> str:
-    """Detect framework from agent files"""
-    folder = Path(folder_path)
+                console.print(f"❌ [red]{cleanup_result.get('error')}[/red]")
     
-    # Check main.py for framework imports
-    main_file = folder / 'main.py'
-    agent_file = folder / 'agent.py'
-    
-    framework_keywords = {
-        'langgraph': ['langgraph', 'StateGraph', 'Graph'],
-        'langchain': ['langchain', 'ConversationChain', 'AgentExecutor'],
-        'llamaindex': ['llama_index', 'VectorStoreIndex', 'QueryEngine']
-    }
-    
-    for file_to_check in [main_file, agent_file]:
-        if file_to_check.exists():
-            try:
-                content = file_to_check.read_text().lower()
-                
-                for framework, keywords in framework_keywords.items():
-                    if any(keyword.lower() in content for keyword in keywords):
-                        return framework
-            except:
-                continue
-    
-    # Check requirements.txt
-    req_file = folder / 'requirements.txt'
-    if req_file.exists():
-        try:
-            content = req_file.read_text().lower()
-            
-            for framework, keywords in framework_keywords.items():
-                if any(keyword.lower() in content for keyword in keywords):
-                    return framework
-        except:
-            pass
-    
-    return 'unknown'
-
+    except Exception as e:
+        console.print(f"❌ [red]Database status error:[/red] {e}")
+        raise click.ClickException("Failed to get database status")
diff --git a/runagent/cli/main.py b/runagent/cli/main.py
index 233d300..1d60c13 100644
--- a/runagent/cli/main.py
+++ b/runagent/cli/main.py
@@ -9,19 +9,17 @@ def runagent():
     """RunAgent CLI - Deploy and manage AI agents easily"""
     pass
 
-# Add all existing commands
-runagent.add_command(commands.init)
 runagent.add_command(commands.setup)
 runagent.add_command(commands.teardown)
+runagent.add_command(commands.init)
 runagent.add_command(commands.template)
-
-# Add new deployment commands
 runagent.add_command(commands.deploy_local)
 runagent.add_command(commands.upload)
 runagent.add_command(commands.start)
 runagent.add_command(commands.deploy)
 runagent.add_command(commands.serve)
 runagent.add_command(commands.run)
+runagent.add_command(commands.db_status)
 
 if __name__ == '__main__':
     runagent()
\ No newline at end of file
diff --git a/runagent/client/__init__.py b/runagent/client/__init__.py
index fa8d68b..d1a8b0c 100644
--- a/runagent/client/__init__.py
+++ b/runagent/client/__init__.py
@@ -1,891 +1,31 @@
 """
-RunAgent client for deploying and managing AI agents.
-"""
-import os
-import time
-import click
-import zipfile
-import inquirer
-import tempfile
-import typing as t
-from pathlib import Path
-from runagent.constants import (
-    TemplateVariant, Framework, TEMPLATE_REPO_URL,
-    TEMPLATE_PREPATH, TEMPLATE_BRANCH
-)
-from runagent.client.exceptions import ValidationError
-from runagent.client.template_downloader import TemplateDownloader
-from runagent.utils.config import Config
-from runagent.client.http import EndpointHandler
-from runagent.utils.enums import ResponseStatus
-from rich.table import Table
-from rich.console import Console
-
-# Console for pretty printing
-console = Console()
-
-_valid_keys: t.Set[str] = set()
-_clients: t.List["RunAgentClient"] = []
-
-
-class AuthenticationError(Exception):
-    """Raised when authentication fails"""
-    pass
-
-
-class ClientError(Exception):
-    """Raised when client operations fail"""
-    pass
-
-
-class RunAgentClient:
-    """Client for interacting with the RunAgent service."""
-
-    def __init__(
-        self,
-        cli_mode: t.Optional[bool] = False,
-        api_key: t.Optional[str] = None,
-        base_url: t.Optional[str] = None
-    ):
-        """Initialize RunAgent client with proper error handling"""
-        
-        self.cli_mode = cli_mode
-        
-        # Get configuration with fallbacks
-        self.api_key = api_key or Config.get_api_key()
-        self.base_url = base_url or Config.get_base_url()
-        
-        # Initialize endpoint handler
-        self.endpoint_handler = EndpointHandler(
-            api_key=self.api_key,
-            base_url=self.base_url
-        )
-        
-        # Add to global clients list
-        _clients.append(self)
-        
-        # If in CLI mode and not configured, show helpful message
-        if cli_mode and not self.is_authenticated():
-            if not api_key:  # Only show if not explicitly passed
-                click.echo(
-                    "⚠️  RunAgent is not configured. "
-                    "Run 'runagent setup --api-key <key>' to get started."
-                )
-
-    def is_authenticated(self) -> bool:
-        """Check if client has valid authentication"""
-        return bool(self.api_key)
-
-    def require_authentication(self, cli_mode: bool = None):
-        """Ensure client is authenticated, raise error if not"""
-        if cli_mode is None:
-            cli_mode = self.cli_mode
-            
-        if not self.is_authenticated():
-            error_msg = "Not authenticated. Run 'runagent setup --api-key <key>' to configure RunAgent."
-            if cli_mode:
-                raise click.ClickException(f"❌ {error_msg}")
-            else:
-                raise AuthenticationError(error_msg)
-
-
-    def validate_connection(self) -> bool:
-        """Validate current connection without raising exceptions"""
-        if not self.is_authenticated():
-            return False
-        
-        try:
-            response = self.endpoint_handler.validate_api_key()
-            return response.get("status") == ResponseStatus.SUCCESS.value
-        except Exception:
-            return False
-
-    def setup(
-        self,
-        base_url: str = None,
-        api_key: str = None,
-        force: bool = False,
-        cli_mode: bool = None
-    ):
-        """Configure RunAgent CLI settings with enhanced validation
-        
-        Args:
-            base_url: API base URL
-            api_key: API key for authentication
-            force: Force reconfiguration even if already configured
-            cli_mode: Enable interactive prompts (None = use instance default)
-        """
-        # Use instance cli_mode if not explicitly provided
-        if cli_mode is None:
-            cli_mode = self.cli_mode
-        
-        # Check if already configured and not forcing
-        if not force and Config.is_configured():
-            current_config = Config.get_user_config()
-            
-            if cli_mode:
-                click.echo("⚠️  RunAgent is already configured:")
-                click.echo(
-                    f"   Base URL: {current_config.get('base_url', 'Not set')}"
-                )
-                click.echo(
-                    f"   User: {current_config.get('email', 'Unknown')}"
-                )
-                
-                if not click.confirm("Do you want to reconfigure?"):
-                    return True
-            else:
-                # In SDK mode, just return success if already configured
-                return True
-        
-        # Handle base URL
-        base_url = base_url or Config.get_base_url()
-        if base_url:
-            # Validate URL format
-            if not base_url.startswith(('http://', 'https://')):
-                base_url = f"https://{base_url}"
-            
-            Config.set_base_url(base_url)
-            if cli_mode:
-                click.echo("✓ Base URL saved successfully!")
-        
-        # Validate API key is provided
-        if not api_key:
-            if cli_mode:
-                click.echo("❌ API key is required for setup")
-            raise ValueError("API key is required for setup")
-        
-        # Test connection before saving
-        if cli_mode:
-            click.echo(f"🔗 Testing connection to {base_url}...")
-        
-        # Create temporary endpoint handler for validation
-        temp_handler = EndpointHandler(api_key=api_key, base_url=base_url)
-        
-        try:
-            response = temp_handler.validate_api_key()
-            
-            if response.get("status") == ResponseStatus.ERROR.value:
-                error_msg = "Authentication failed. Please check your API key"
-                if cli_mode:
-                    click.echo(f"❌ {error_msg}")
-                else:
-                    raise AuthenticationError(error_msg)
-                return False
-            
-            # Only save if validation succeeds
-            Config.set_api_key(api_key)
-            if cli_mode:
-                click.echo("✓ API key saved successfully!")
-            
-            # Update client instance
-            self.api_key = api_key
-            self.base_url = base_url
-            self.endpoint_handler = EndpointHandler(
-                api_key=api_key,
-                base_url=base_url
-            )
-            
-            if cli_mode:
-                click.echo("✅ API key validation successful!")
-            
-            # Display and save user info
-            if "data" in response and "user" in response["data"]:
-                user = response["data"]["user"]
-                
-                if cli_mode:
-                    table = Table(title="User Information")
-                    table.add_column("Field", style="cyan")
-                    table.add_column("Value", style="green")
-
-                    for key, value in user.items():
-                        table.add_row(key, str(value))
-                        Config.set_user_config(key, value)
-                    console.print(table)
-                else:
-                    # In SDK mode, just save the config silently
-                    for key, value in user.items():
-                        Config.set_user_config(key, value)
-            
-            return True
-            
-        except (ConnectionError, AuthenticationError, ClientError) as e:
-            error_msg = f"Setup failed: {str(e)}"
-            if cli_mode:
-                click.echo(f"❌ {error_msg}")
-            else:
-                raise  # Re-raise the original exception for SDK mode
-            return False
-        except Exception as e:
-            error_msg = f"Unexpected error during setup: {str(e)}"
-            if cli_mode:
-                click.echo(f"❌ {error_msg}")
-            else:
-                raise  # Re-raise for SDK mode
-            return False
-
-    def teardown(self, confirm: bool = False, cli_mode: bool = None):
-        """Remove all RunAgent configuration and cached data
-        
-        Args:
-            confirm: Skip confirmation prompt if True
-            cli_mode: Enable interactive prompts (None = use instance default)
-        """
-        # Use instance cli_mode if not explicitly provided
-        if cli_mode is None:
-            cli_mode = self.cli_mode
-        
-        if not confirm and cli_mode:
-            current_config = Config.get_user_config()
-            if current_config:
-                click.echo("📋 Current configuration:")
-                click.echo(
-                    f"   Base URL: {current_config.get('base_url', 'Not set')}"
-                )
-                click.echo(
-                    f"   User: {current_config.get('email', 'Unknown')}"
-                )
-                click.echo(
-                    f"   API Key: {'*' * 8}..."
-                    f"{current_config.get('api_key', '')[-4:] if current_config.get('api_key') else 'Not set'}"
-                )
-            
-            if not click.confirm(
-                "⚠️  This will remove all RunAgent configuration. Continue?"
-            ):
-                if cli_mode:
-                    click.echo("Teardown cancelled.")
-                return False
-        
-        try:
-            # Clear all user configuration
-            if Config.clear_user_config() and cli_mode:
-                click.echo("✓ User configuration removed")
-            
-            # Clear any deployment info in current directory
-            deployments_dir = Path.cwd() / ".deployments"
-            if deployments_dir.exists():
-                import shutil
-                shutil.rmtree(deployments_dir)
-                if cli_mode:
-                    click.echo("✓ Local deployment cache cleared")
-            
-            # Reset client instance
-            self.api_key = None
-            self.base_url = Config.get_base_url()  # Will fall back to default
-            self.endpoint_handler = EndpointHandler(
-                api_key=None,
-                base_url=self.base_url
-            )
-            
-            if cli_mode:
-                click.echo("✅ RunAgent teardown completed successfully!")
-                click.echo(
-                    "💡 Run 'runagent setup --api-key <key>' to reconfigure"
-                )
-            
-            return True
-            
-        except Exception as e:
-            error_msg = f"Error during teardown: {str(e)}"
-            if cli_mode:
-                click.echo(f"❌ {error_msg}")
-            else:
-                raise  # Re-raise for SDK mode
-            return False
+RunAgent SDK - Standalone Python SDK for deploying and managing AI agents.
 
-    def init(
-        self,
-        framework: str = None,
-        template: str = None, 
-        folder: str = None,
-        cli_mode: bool = None
-    ):
-        """🚀 Initialize a new RunAgent agent with framework selection
-        
-        Args:
-            framework: Framework to use (defaults to 'langchain' in SDK mode)
-            template: Template variant (defaults to 'basic' in SDK mode)
-            folder: Project folder name
-            cli_mode: Enable interactive prompts (None = use instance default)
-        """
-        # Use instance cli_mode if not explicitly provided
-        if cli_mode is None:
-            cli_mode = self.cli_mode
-        
-        # Check authentication first
-        # self.require_authentication(cli_mode=cli_mode)
-        
-        if cli_mode:
-            click.secho(
-                "🚀 Initializing RunAgent agent...",
-                fg='cyan',
-                bold=True
-            )
-            click.secho("🔐 Checking authentication...", fg='yellow')
-        
-        # Validate connection
-        # if not self.validate_connection():
-        #     error_msg = "Authentication validation failed"
-        #     if cli_mode:
-        #         click.echo(f"❌ {error_msg}")
-        #         click.echo(
-        #             "💡 Run 'runagent setup --api-key <key>' to reconfigure"
-        #         )
-        #     else:
-        #         raise AuthenticationError(error_msg)
-        #     return False
-        
-        # if cli_mode:
-        #     with click.progressbar(range(5), label='🔄 Authenticating') as bar:
-        #         for _ in bar:
-        #             time.sleep(0.2)
-        #     click.secho("✅ Authentication successful!\n", fg='green')
-        
-        # Handle folder name
-        if not folder:
-            if cli_mode:
-                folder = click.prompt(
-                    "📁 Agent folder name",
-                    default=os.path.basename(os.getcwd())
-                )
-            else:
-                # Use current directory name as default
-                folder = os.path.basename(os.getcwd())
-        
-        agent_dir = Path.cwd() / folder
-        
-        # Check if folder already exists and handle appropriately
-        if agent_dir.exists() and any(agent_dir.iterdir()):
-            if cli_mode:
-                if not click.confirm(
-                    f"⚠️  Folder '{folder}' already exists and is not empty. "
-                    "Continue?"
-                ):
-                    click.echo("Agent initialization cancelled.")
-                    return False
-            else:
-                raise ValueError(
-                    f"Folder '{folder}' already exists and is not empty"
-                )
-        
-        project_dir.mkdir(parents=True, exist_ok=True)
-        
-        # Get available templates from repository
-        try:
-            available_templates = self._get_available_templates(
-                cli_mode=cli_mode
-            )
-        except Exception as e:
-            error_msg = f"Failed to fetch available templates: {str(e)}"
-            if cli_mode:
-                click.echo(f"❌ {error_msg}")
-            else:
-                raise RuntimeError(error_msg)
-            return False
-
-        # Handle framework selection
-        if cli_mode:
-            # Interactive mode - let user select even if framework is provided
-            if not framework:
-                selected_framework = self._select_framework_interactive(available_templates)
-                if not selected_framework:
-                    return False
-            else:
-                # Validate provided framework
-                if framework not in available_templates:
-                    click.echo(f"❌ Framework '{framework}' not available. Available: {list(available_templates.keys())}")
-                    selected_framework = self._select_framework_interactive(available_templates)
-                    if not selected_framework:
-                        return False
-                else:
-                    selected_framework = framework
-        else:
-            # SDK mode - use defaults
-            if not framework:
-                framework = "langchain"  # Default framework
-            
-            # Validate framework exists
-            if framework not in available_templates:
-                # Fallback to first available framework if default doesn't exist
-                if available_templates:
-                    framework = list(available_templates.keys())[0]
-                    if not cli_mode:  # Only log in SDK mode
-                        print(f"Warning: Requested framework not found, using '{framework}' instead")
-                else:
-                    raise RuntimeError("No templates available from repository")
-            
-            selected_framework = framework
-
-        # Handle template selection  
-        if cli_mode:
-            # Interactive mode - let user select even if template is provided
-            if not template:
-                selected_template = self._select_template_interactive(
-                    available_templates, selected_framework
-                )
-                if not selected_template:
-                    return False
-            else:
-                # Validate provided template
-                framework_templates = available_templates.get(selected_framework, [])
-                if template not in framework_templates:
-                    click.echo(f"❌ Template '{template}' not available for framework '{selected_framework}'. Available: {framework_templates}")
-                    selected_template = self._select_template_interactive(
-                        available_templates, selected_framework
-                    )
-                    if not selected_template:
-                        return False
-                else:
-                    selected_template = template
-        else:
-            # SDK mode - use defaults
-            if not template:
-                template = "basic"  # Default template
-            
-            # Validate template exists
-            framework_templates = available_templates.get(selected_framework, [])
-            if template not in framework_templates:
-                # Fallback to first available template if default doesn't exist
-                if framework_templates:
-                    template = framework_templates[0]
-                    if not cli_mode:  # Only log in SDK mode
-                        print(f"Warning: Requested template not found, using '{template}' instead")
-                else:
-                    raise RuntimeError(f"No templates available for framework '{selected_framework}'")
-            
-            selected_template = template
-
-        if cli_mode:
-            click.secho(
-                f"\n🛠️  Selected framework: {selected_framework} "
-                f"({selected_template})\n",
-                fg='magenta',
-                bold=True
-            )
-        else:
-            # In SDK mode, show what was selected
-            print(f"📦 Initializing project with {selected_framework}/{selected_template}")
-
-        # Download and generate template files
-        return self._download_and_setup_template(
-            agent_dir,
-            selected_framework,
-            selected_template,
-            folder,
-            cli_mode=cli_mode
-        )
-
-    def _select_framework_interactive(self, available_templates: dict) -> str:
-        """Interactive framework selection for CLI mode"""
-        frameworks = list(available_templates.keys())
-        framework_choices = [
-            (
-                f"{'🧠' if 'langchain' in fw.lower() else '🔧' if 'langgraph' in fw.lower() else '📜' if 'llamaindex' in fw.lower() else '⚙️'} "
-                f"{fw}"
-            )
-            for fw in frameworks
-        ]
-
-        click.secho("🎯 Select a framework using arrow keys:", fg='blue')
-        questions = [
-            inquirer.List(
-                'framework',
-                message="",
-                choices=framework_choices,
-                carousel=True
-            )
-        ]
-        answers = inquirer.prompt(questions)
-        
-        if not answers:  # User cancelled
-            return None
-            
-        return answers['framework'].split(' ', 1)[1]  # Extract framework name
-
-    def _select_template_interactive(self, available_templates: dict, framework: str) -> str:
-        """Interactive template selection for CLI mode"""
-        framework_templates = available_templates.get(framework, [])
-        template_choices = [f"🔰 {tmpl}" for tmpl in framework_templates]
-
-        click.secho(
-            "\n🧱 Select template type using arrow keys:",
-            fg='blue'
-        )
-        questions = [
-            inquirer.List(
-                'template',
-                message="",
-                choices=template_choices,
-                carousel=True
-            )
-        ]
-        answers = inquirer.prompt(questions)
-        
-        if not answers:  # User cancelled
-            return None
-            
-        return answers['template'].split(' ', 1)[1]  # Extract template name
-
-    def _get_available_templates(self, cli_mode: bool = False):
-        """Fetch available templates from the git repository"""
-        if cli_mode:
-            click.echo("📋 Fetching available templates...")
-        
-        downloader = TemplateDownloader(
-            repo_url=TEMPLATE_REPO_URL,
-            branch=TEMPLATE_BRANCH
-        )
-        
-        try:
-            templates = downloader.list_available_templates(TEMPLATE_PREPATH)
-            if cli_mode:
-                click.echo("✅ Templates fetched successfully")
-            return templates
-        except Exception as e:
-            if cli_mode:
-                click.echo(f"❌ Error fetching templates: {str(e)}")
-            raise
-
-    def _select_framework(
-        self,
-        framework: str,
-        available_templates: dict,
-        cli_mode: bool = False
-    ) -> str:
-        """Select framework with validation against available templates"""
-        
-        # Validate framework
-        if framework not in available_templates:
-            error_msg = (
-                f"Framework '{framework}' not available. "
-                f"Available: {list(available_templates.keys())}"
-            )
-            if cli_mode:
-                click.echo(f"❌ {error_msg}")
-            else:
-                raise ValueError(error_msg)
-            return None
-        return framework
-        
-        # Interactive selection for CLI mode
-        if cli_mode:
-            frameworks = list(available_templates.keys())
-            framework_choices = [
-                (
-                    f"{'🧠' if 'langchain' in fw.lower() else '🔧' if 'langgraph' in fw.lower() else '📜' if 'flask' in fw.lower() else '⚙️'} "
-                    f"{fw}"
-                )
-                for fw in frameworks
-            ]
-
-            click.secho("🎯 Select a framework using arrow keys:", fg='blue')
-            questions = [
-                inquirer.List(
-                    'framework',
-                    message="",
-                    choices=framework_choices,
-                    carousel=True
-                )
-            ]
-            answers = inquirer.prompt(questions)
-            
-            if not answers:  # User cancelled
-                return None
-                
-            return answers['framework'].split(' ', 1)[1]  # Extract framework name
-        else:
-            # SDK mode: use provided framework
-            return framework
-
-    def _select_template(
-        self,
-        template: str,
-        available_templates: dict,
-        framework: str,
-        cli_mode: bool = False
-    ) -> str:
-        """Select template with validation against available templates"""
-        
-        framework_templates = available_templates.get(framework, [])
-        
-        # Validate template
-        if template not in framework_templates:
-            error_msg = (
-                f"Template '{template}' not available for framework "
-                f"'{framework}'. Available: {framework_templates}"
-            )
-            if cli_mode:
-                click.echo(f"❌ {error_msg}")
-            else:
-                raise ValueError(error_msg)
-            return None
-        return template
-        
-        # Interactive selection for CLI mode
-        if cli_mode:
-            template_choices = [f"🔰 {tmpl}" for tmpl in framework_templates]
-
-            click.secho(
-                "\n🧱 Select template type using arrow keys:",
-                fg='blue'
-            )
-            questions = [
-                inquirer.List(
-                    'template',
-                    message="",
-                    choices=template_choices,
-                    carousel=True
-                )
-            ]
-            answers = inquirer.prompt(questions)
-            
-            if not answers:  # User cancelled
-                return None
-                
-            return answers['template'].split(' ', 1)[1]  # Extract template name
-        else:
-            # SDK mode: use provided template
-            return template
-
-    def _download_and_setup_template(
-        self,
-        agent_dir: Path,
-        framework: str,
-        template: str,
-        folder: str,
-        cli_mode: bool = False
-    ):
-        """Download template from git repository and set up the agent"""
-        
-        try:
-            if cli_mode:
-                click.secho("📦 Downloading project template...", fg='cyan')
-            else:
-                print("📦 Downloading project template...")
-            
-            # Initialize template downloader
-            downloader = TemplateDownloader(
-                repo_url=TEMPLATE_REPO_URL,
-                branch=TEMPLATE_BRANCH
-            )
-            
-            # Download template to agent directory
-            downloader.download_template(
-                prepath=TEMPLATE_PREPATH,
-                framework=framework,
-                template=template,
-                target_folder=str(agent_dir)
-            )
-            
-            # Verify essential files were downloaded
-            essential_files = ['main.py', 'agent.py', 'requirements.txt']
-            missing_files = []
-            for file in essential_files:
-                if not (project_dir / file).exists():
-                    missing_files.append(file)
-            
-            if missing_files:
-                raise RuntimeError(f"Template download incomplete. Missing files: {missing_files}")
-            
-            # Create project configuration
-            config_content = {
-                "agent_name": folder,
-                "framework": framework,
-                "template": template,
-                "version": "0.1.0",
-                "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
-                "template_source": {
-                    "repo_url": TEMPLATE_REPO_URL,
-                    "branch": TEMPLATE_BRANCH,
-                    "path": f"{TEMPLATE_PREPATH}/{framework}/{template}"
-                },
-                "architecture": {
-                    "main_file": "main.py",
-                    "agent_file": "agent.py",
-                    "entry_point": "run"
-                }
-            }
-            Config.create_config(agent_dir, config_content)
-            
-            if cli_mode:
-                click.secho(
-                    f"✅ Successfully initialized RunAgent agent in "
-                    f"📁 {folder}\n",
-                    fg='green',
-                    bold=True
-                )
-                
-                # List created files
-                click.secho("🗂️  Files created:", fg='cyan')
-                for file_path in agent_dir.rglob('*'):
-                    if (
-                        file_path.is_file()
-                        and not file_path.name.startswith('.')
-                        and file_path.name != 'runagent.config.json'  # Don't show config file
-                    ):
-                        relative_path = file_path.relative_to(agent_dir)
-                        click.echo(f"  - {relative_path}")
-
-                click.secho("\n📝 Next steps:", fg='yellow')
-                click.echo("  1️⃣  Update your API keys in `.env` file")
-                click.echo("  2️⃣  Customize the agent logic in `agent.py`")
-                click.echo("  3️⃣  Test locally: `cd {folder} && python main.py`")
-                click.echo(f"  4️⃣  Deploy: `runagent deploy --folder {folder}`")
-            else:
-                # SDK mode - simpler output
-                print(f"✅ Successfully initialized RunAgent project in {folder}")
-                print(f"📁 Framework: {framework}")
-                print(f"📄 Template: {template}")
-                print("📋 Files created: main.py, agent.py, requirements.txt, .env")
-                print("🚀 Next: Update .env file and run 'python main.py' to test")
-            
-            return True
-
-        except Exception as e:
-            error_msg = f"Error setting up project: {str(e)}"
-            if cli_mode:
-                click.secho(f"❌ {error_msg}", fg='red', err=True)
-            else:
-                print(f"❌ {error_msg}")
-                raise RuntimeError(error_msg)
-            return False
+This module provides a comprehensive SDK that can work independently of the CLI.
+"""
 
-    def list_templates(self, cli_mode: bool = None):
-        """List all available templates from the repository
-        
-        Args:
-            cli_mode: Enable pretty printing (None = use instance default)
-        """
-        if cli_mode is None:
-            cli_mode = self.cli_mode
-        
-        try:
-            available_templates = self._get_available_templates(
-                cli_mode=cli_mode
-            )
-            
-            if cli_mode:
-                click.secho("📋 Available Templates:", fg='cyan', bold=True)
-                
-                for framework, templates in available_templates.items():
-                    click.secho(f"\n🎯 {framework}:", fg='blue', bold=True)
-                    for template in templates:
-                        click.echo(f"  - {template}")
-            
-            return available_templates
-            
-        except Exception as e:
-            error_msg = f"Failed to list templates: {str(e)}"
-            if cli_mode:
-                click.echo(f"❌ {error_msg}")
-            else:
-                raise RuntimeError(error_msg)
-            return None
-    def validate_agent(self, agent_dir: t.Union[str, Path]) -> t.Tuple[bool, t.Dict[str, t.Any]]:
-        """Validate the agent structure and configuration.
-        
-        Args:
-            agent_dir: Path to the agent directory
-            
-        Returns:
-            Tuple of (is_valid, metadata_dict)
-        """
-        agent_dir = Path(agent_dir)
-        metadata = {
-            "file_structure": {},
-            "total_size": 0,
-            "file_count": 0,
-            "config_exists": False,
-            "run_function_exists": False
-        }
-        
-        # Check if runagent config exists
-        config_path = agent_dir / "runagent.yaml"
-        if not config_path.exists():
-            return False, metadata
-        metadata["config_exists"] = True
-        
-        # Check if runagent.py exists and has run function
-        runagent_path = agent_dir / "runagent.py"
-        if runagent_path.exists():
-            try:
-                with open(runagent_path, 'r') as f:
-                    content = f.read()
-                    metadata["run_function_exists"] = "def run(" in content
-            except Exception:
-                pass
-        
-        # Collect file structure and metadata
-        for path in agent_dir.rglob("*"):
-            if path.is_file():
-                rel_path = str(path.relative_to(agent_dir))
-                size = path.stat().st_size
-                metadata["file_structure"][rel_path] = {
-                    "size": size,
-                    "type": path.suffix
-                }
-                metadata["total_size"] += size
-                metadata["file_count"] += 1
-        
-        is_valid = metadata["config_exists"] and metadata["run_function_exists"]
-        return is_valid, metadata
+from .sdk import RunAgentSDK
+from .exceptions import (
+    RunAgentError,
+    AuthenticationError,
+    ValidationError,
+    ConnectionError,
+    ServerError
+)
 
-    def upload_agent(self, agent_dir: t.Union[str, Path] = None) -> bool:
-        """Upload an agent to RunAgent.
-        
-        Args:
-            agent_dir: Path to agent directory (defaults to current directory)
-            
-        Returns:
-            bool: True if upload was successful
-        """
-        if agent_dir is None:
-            agent_dir = Path.cwd()
-        else:
-            agent_dir = Path(agent_dir)
-        
-        # Validate agent
-        is_valid, metadata = self.validate_agent(agent_dir)
-        if not is_valid:
-            error_msg = "Invalid agent structure. Make sure runagent.yaml exists and runagent.py contains a run function."
-            if self.cli_mode:
-                click.secho(f"❌ {error_msg}", fg='red', err=True)
-            else:
-                raise ValidationError(error_msg)
-            return False
-        
-        try:
-            # Create temporary directory for zip
-            with tempfile.TemporaryDirectory() as temp_dir:
-                temp_path = Path(temp_dir)
-                zip_path = temp_path / "agent.zip"
-                
-                # Create zip file
-                with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
-                    for path in agent_dir.rglob("*"):
-                        if path.is_file():
-                            arcname = str(path.relative_to(agent_dir))
-                            zipf.write(path, arcname)
-                
-                # Upload agent
-                response = self.endpoint_handler.upload_agent(
-                    project_zip=zip_path,
-                    metadata=metadata
-                )
-                
-                if self.cli_mode:
-                    if response.get("status") == ResponseStatus.SUCCESS.value:
-                        click.secho("✅ Agent uploaded successfully!", fg='green')
-                    else:
-                        click.secho(f"❌ Upload failed: {response.get('message')}", fg='red', err=True)
-                
-                return response.get("status") == ResponseStatus.SUCCESS.value
-                
-        except Exception as e:
-            error_msg = f"Error uploading agent: {str(e)}"
-            if self.cli_mode:
-                click.secho(f"❌ {error_msg}", fg='red', err=True)
-            else:
-                raise RuntimeError(error_msg)
-            return False
\ No newline at end of file
+# Main SDK class for easy import
+RunAgent = RunAgentSDK
+
+# Version info
+__version__ = "0.1.0"
+
+# Expose main components
+__all__ = [
+    "RunAgentSDK",
+    "RunAgent",
+    "RunAgentError", 
+    "AuthenticationError",
+    "ValidationError",
+    "ConnectionError",
+    "ServerError"
+]
\ No newline at end of file
diff --git a/runagent/client/agents.py b/runagent/client/agents.py
new file mode 100644
index 0000000..a537585
--- /dev/null
+++ b/runagent/client/agents.py
@@ -0,0 +1,165 @@
+"""
+Agent management utilities.
+"""
+
+import typing as t
+from pathlib import Path
+
+from .exceptions import ValidationError
+
+
+class AgentManager:
+    """Utilities for agent validation and management"""
+    
+    def __init__(self, config):
+        """
+        Initialize agent manager.
+        
+        Args:
+            config: SDK configuration object
+        """
+        self.config = config
+    
+    def validate_agent(self, folder: str) -> t.Tuple[bool, t.Dict[str, t.Any]]:
+        """
+        Validate agent project structure.
+        
+        Args:
+            folder: Path to agent folder
+            
+        Returns:
+            Tuple of (is_valid, validation_details)
+        """
+        folder_path = Path(folder)
+        if not folder_path.exists():
+            return False, {"error": f"Folder not found: {folder}"}
+        
+        validation_details = {
+            "folder_exists": True,
+            "files_found": [],
+            "missing_files": [],
+            "framework": "unknown",
+            "valid": False
+        }
+        
+        # Check for required files
+        required_files = ["main.py"]
+        optional_files = ["agent.py", "requirements.txt", ".env"]
+        
+        for file_name in required_files + optional_files:
+            file_path = folder_path / file_name
+            if file_path.exists():
+                validation_details["files_found"].append(file_name)
+            elif file_name in required_files:
+                validation_details["missing_files"].append(file_name)
+        
+        # Check if main.py has run function
+        main_file = folder_path / "main.py"
+        if main_file.exists():
+            try:
+                content = main_file.read_text()
+                if "def run(" in content:
+                    validation_details["has_run_function"] = True
+                else:
+                    validation_details["has_run_function"] = False
+                    validation_details["missing_files"].append("run function in main.py")
+            except Exception as e:
+                validation_details["main_py_error"] = str(e)
+        
+        # Detect framework
+        validation_details["framework"] = self.detect_framework(folder)
+        
+        # Overall validation
+        validation_details["valid"] = (
+            len(validation_details["missing_files"]) == 0 and
+            validation_details.get("has_run_function", False)
+        )
+        
+        return validation_details["valid"], validation_details
+    
+    def detect_framework(self, folder: str) -> str:
+        """
+        Auto-detect framework used in agent project.
+        
+        Args:
+            folder: Path to agent folder
+            
+        Returns:
+            Detected framework name
+        """
+        folder_path = Path(folder)
+        if not folder_path.exists():
+            return "unknown"
+        
+        framework_keywords = {
+            'langgraph': ['langgraph', 'StateGraph', 'Graph'],
+            'langchain': ['langchain', 'ConversationChain', 'AgentExecutor'],
+            'llamaindex': ['llama_index', 'VectorStoreIndex', 'QueryEngine']
+        }
+        
+        # Check main.py and agent.py for imports
+        for file_to_check in ['main.py', 'agent.py']:
+            file_path = folder_path / file_to_check
+            if file_path.exists():
+                try:
+                    content = file_path.read_text().lower()
+                    for framework, keywords in framework_keywords.items():
+                        if any(keyword.lower() in content for keyword in keywords):
+                            return framework
+                except:
+                    continue
+        
+        # Check requirements.txt
+        req_file = folder_path / 'requirements.txt'
+        if req_file.exists():
+            try:
+                content = req_file.read_text().lower()
+                for framework, keywords in framework_keywords.items():
+                    if any(keyword.lower() in content for keyword in keywords):
+                        return framework
+            except:
+                pass
+        
+        return 'unknown'
+    
+    def get_project_info(self, folder: str) -> t.Dict[str, t.Any]:
+        """
+        Get comprehensive information about an agent project.
+        
+        Args:
+            folder: Path to agent folder
+            
+        Returns:
+            Project information dictionary
+        """
+        folder_path = Path(folder)
+        
+        info = {
+            "folder_path": str(folder_path.absolute()),
+            "folder_exists": folder_path.exists(),
+            "framework": "unknown",
+            "valid": False,
+            "files": [],
+            "size_mb": 0
+        }
+        
+        if not folder_path.exists():
+            return info
+        
+        # Get file list and size
+        total_size = 0
+        for file_path in folder_path.rglob("*"):
+            if file_path.is_file():
+                info["files"].append({
+                    "name": str(file_path.relative_to(folder_path)),
+                    "size": file_path.stat().st_size
+                })
+                total_size += file_path.stat().st_size
+        
+        info["size_mb"] = round(total_size / 1024 / 1024, 2)
+        
+        # Get validation info
+        is_valid, validation_details = self.validate_agent(folder)
+        info.update(validation_details)
+        
+        return info
diff --git a/runagent/client/config.py b/runagent/client/config.py
new file mode 100644
index 0000000..abced1e
--- /dev/null
+++ b/runagent/client/config.py
@@ -0,0 +1,193 @@
+"""
+SDK Configuration management.
+"""
+
+import os
+import json
+import typing as t
+from pathlib import Path
+
+from ..constants import (
+    ENV_RUNAGENT_API_KEY,
+    ENV_RUNAGENT_BASE_URL,
+    DEFAULT_BASE_URL,
+    LOCAL_CACHE_DIRECTORY,
+    USER_DATA_FILE_NAME
+)
+from .exceptions import AuthenticationError, ValidationError
+
+
+class SDKConfig:
+    """Manage SDK configuration and authentication"""
+    
+    def __init__(
+        self,
+        api_key: t.Optional[str] = None,
+        base_url: t.Optional[str] = None,
+        config_file: t.Optional[str] = None
+    ):
+        """
+        Initialize configuration.
+        
+        Args:
+            api_key: API key (overrides env var and config file)
+            base_url: Base URL (overrides env var and config file)
+            config_file: Path to custom config file
+        """
+        self.config_file = Path(config_file) if config_file else self._get_default_config_path()
+        
+        # Load configuration from various sources
+        self._config = self._load_config()
+        
+        # Override with provided values
+        if api_key:
+            self._config["api_key"] = api_key
+        if base_url:
+            self._config["base_url"] = base_url
+    
+    def _get_default_config_path(self) -> Path:
+        """Get default config file path"""
+        config_dir = Path(LOCAL_CACHE_DIRECTORY)
+        config_dir.mkdir(exist_ok=True)
+        return config_dir / USER_DATA_FILE_NAME
+    
+    def _load_config(self) -> t.Dict[str, t.Any]:
+        """Load configuration from all sources"""
+        config = {}
+        
+        # 1. Load from config file
+        if self.config_file.exists():
+            try:
+                with open(self.config_file, 'r') as f:
+                    config.update(json.load(f))
+            except (json.JSONDecodeError, IOError):
+                pass
+        
+        # 2. Override with environment variables
+        if os.getenv(ENV_RUNAGENT_API_KEY):
+            config["api_key"] = os.getenv(ENV_RUNAGENT_API_KEY)
+        
+        if os.getenv(ENV_RUNAGENT_BASE_URL):
+            config["base_url"] = os.getenv(ENV_RUNAGENT_BASE_URL)
+        elif "base_url" not in config:
+            config["base_url"] = DEFAULT_BASE_URL
+        
+        return config
+    
+    def save_config(self) -> bool:
+        """Save current configuration to file"""
+        try:
+            self.config_file.parent.mkdir(exist_ok=True)
+            with open(self.config_file, 'w') as f:
+                json.dump(self._config, f, indent=2)
+            return True
+        except (IOError, OSError):
+            return False
+    
+    def setup(
+        self,
+        api_key: t.Optional[str] = None,
+        base_url: t.Optional[str] = None,
+        save: bool = True
+    ) -> bool:
+        """
+        Setup and validate configuration.
+        
+        Args:
+            api_key: API key for authentication
+            base_url: Base URL for the service
+            save: Whether to save to config file
+            
+        Returns:
+            True if setup is successful
+            
+        Raises:
+            AuthenticationError: If authentication fails
+            ValidationError: If configuration is invalid
+        """
+        # Update configuration
+        if api_key:
+            self._config["api_key"] = api_key
+        if base_url:
+            if not base_url.startswith(('http://', 'https://')):
+                base_url = f"https://{base_url}"
+            self._config["base_url"] = base_url
+        
+        # Validate configuration
+        if not self._config.get("api_key"):
+            raise ValidationError("API key is required")
+        
+        # Test authentication
+        if not self._test_authentication():
+            raise AuthenticationError("Authentication failed with provided credentials")
+        
+        # Save if requested
+        if save:
+            self.save_config()
+        
+        return True
+    
+    def _test_authentication(self) -> bool:
+        """Test authentication with current configuration"""
+        try:
+            from .http import EndpointHandler
+            handler = EndpointHandler(
+                api_key=self._config.get("api_key"),
+                base_url=self._config.get("base_url")
+            )
+            response = handler.validate_api_key()
+            return response.get("status") == "success"
+        except Exception:
+            return False
+    
+    def is_configured(self) -> bool:
+        """Check if SDK is properly configured"""
+        return bool(self._config.get("api_key") and self._config.get("base_url"))
+    
+    def is_authenticated(self) -> bool:
+        """Check if current configuration is authenticated"""
+        return self.is_configured() and self._test_authentication()
+    
+    def get_status(self) -> t.Dict[str, t.Any]:
+        """Get detailed configuration status"""
+        return {
+            "configured": self.is_configured(),
+            "authenticated": self.is_authenticated() if self.is_configured() else False,
+            "api_key_set": bool(self._config.get("api_key")),
+            "base_url": self._config.get("base_url"),
+            "user_info": {
+                k: v for k, v in self._config.items() 
+                if k not in ["api_key", "base_url"]
+            },
+            "config_file": str(self.config_file),
+            "config_file_exists": self.config_file.exists()
+        }
+    
+    def clear(self) -> bool:
+        """Clear all configuration"""
+        try:
+            if self.config_file.exists():
+                self.config_file.unlink()
+            self._config.clear()
+            return True
+        except (IOError, OSError):
+            return False
+    
+    # Property accessors
+    @property
+    def api_key(self) -> t.Optional[str]:
+        """Get API key"""
+        return self._config.get("api_key")
+    
+    @property 
+    def base_url(self) -> str:
+        """Get base URL"""
+        return self._config.get("base_url", DEFAULT_BASE_URL)
+    
+    @property
+    def user_info(self) -> t.Dict[str, t.Any]:
+        """Get user information"""
+        return {
+            k: v for k, v in self._config.items()
+            if k not in ["api_key", "base_url"]
+        }
\ No newline at end of file
diff --git a/runagent/client/deployment/__init__.py b/runagent/client/deployment/__init__.py
new file mode 100644
index 0000000..2f5db5b
--- /dev/null
+++ b/runagent/client/deployment/__init__.py
@@ -0,0 +1,8 @@
+"""
+Deployment modules for local and remote agent deployment.
+"""
+
+from .local import LocalDeployment
+from .remote import RemoteDeployment
+
+__all__ = ["LocalDeployment", "RemoteDeployment"]
\ No newline at end of file
diff --git a/runagent/client/deployment/local.py b/runagent/client/deployment/local.py
new file mode 100644
index 0000000..e1375e0
--- /dev/null
+++ b/runagent/client/deployment/local.py
@@ -0,0 +1,285 @@
+"""
+Local deployment management.
+"""
+
+import typing as t
+import requests
+import time
+from pathlib import Path
+
+from ..local_client import LocalClient
+from ..exceptions import ValidationError, ConnectionError
+
+
+class LocalDeployment:
+    """Manage local agent deployments"""
+    
+    def __init__(self, config):
+        """
+        Initialize local deployment manager.
+        
+        Args:
+            config: SDK configuration object
+        """
+        self.config = config
+        self.client = LocalClient()
+        self.local_server_url = "http://127.0.0.1:8450"
+    
+    def deploy_agent(
+        self,
+        folder_path: str,
+        framework: t.Optional[str] = None,
+        replace_agent_id: t.Optional[str] = None
+    ) -> t.Dict[str, t.Any]:
+        """
+        Deploy an agent locally.
+        
+        Args:
+            folder_path: Path to agent folder
+            framework: Framework type (auto-detected if None)
+            replace_agent_id: Optional agent to replace
+            
+        Returns:
+            Deployment result
+        """
+        folder_path = Path(folder_path)
+        if not folder_path.exists():
+            raise ValidationError(f"Folder not found: {folder_path}")
+        
+        # Auto-detect framework if not provided
+        if not framework:
+            framework = self._detect_framework(folder_path)
+        
+        metadata = {"framework": framework}
+        
+        return self.client.deploy_agent(
+            folder_path=str(folder_path),
+            metadata=metadata,
+            replace_agent_id=replace_agent_id
+        )
+    
+    def list_agents(self) -> t.List[t.Dict[str, t.Any]]:
+        """List all local agents"""
+        result = self.client.list_local_agents()
+        return result.get("agents", []) if result.get("success") else []
+    
+    def get_agent_info(self, agent_id: str) -> t.Dict[str, t.Any]:
+        """Get information about a local agent"""
+        return self.client.get_agent_info(agent_id)
+    
+    def run_agent(self, agent_id: str, input_data: t.Dict[str, t.Any]) -> t.Dict[str, t.Any]:
+        """
+        Run a local agent via HTTP server (not direct execution)
+        
+        This method attempts to run the agent via the local HTTP server first.
+        If the server is not running, it falls back to direct execution.
+        """
+        # First, try to run via HTTP server
+        try:
+            result = self._run_agent_via_http(agent_id, input_data)
+            
+            # Fix the response format - the server returns a different format than expected
+            if isinstance(result, dict):
+                # Check if this is the server response format
+                if 'success' in result and 'result' in result and 'agent_id' in result:
+                    # This is the server format, return as-is but ensure it matches expected format
+                    return result
+                elif 'result' in result and 'errors' in result:
+                    # This is the direct execution format, convert to server format
+                    return {
+                        'success': result.get('success', True),
+                        'result': result.get('result'),
+                        'error': result.get('errors')[0] if result.get('errors') else None,
+                        'agent_id': agent_id
+                    }
+            
+            return result
+            
+        except ConnectionError:
+            # If HTTP server is not available, fall back to direct execution
+            print("⚠️ Local server not running, executing agent directly...")
+            return self.client.run_agent(agent_id, input_data)
+    
+    def _run_agent_via_http(self, agent_id: str, input_data: t.Dict[str, t.Any]) -> t.Dict[str, t.Any]:
+        """
+        Run agent via HTTP server
+        
+        Args:
+            agent_id: Agent identifier
+            input_data: Input data for the agent
+            
+        Returns:
+            Agent execution result
+            
+        Raises:
+            ConnectionError: If server is not reachable
+        """
+        url = f"{self.local_server_url}/agents/{agent_id}/run"
+        
+        try:
+            # Make HTTP request to local server
+            response = requests.post(
+                url,
+                json=input_data,
+                timeout=300,  # 5 minute timeout
+                headers={'Content-Type': 'application/json'}
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                
+                # Debug: Print the raw response to understand the format
+                print(f"🔍 Raw HTTP response: {result}")
+                
+                # The server response format is different from what we expect
+                # Server returns: {"success": bool, "result": {...}, "error": str|null, "execution_time": float, "agent_id": str}
+                # We need to check if the result is successful and extract the content properly
+                
+                if result.get('success') and result.get('result'):
+                    # Server returned success - return the result in the expected format
+                    return {
+                        'success': True,
+                        'result': result['result'],
+                        'error': None,
+                        'agent_id': agent_id,
+                        'execution_time': result.get('execution_time')
+                    }
+                else:
+                    # Server returned failure - check for error details
+                    error_msg = result.get('error') or 'Unknown server error'
+                    return {
+                        'success': False,
+                        'result': None,
+                        'error': error_msg,
+                        'agent_id': agent_id,
+                        'execution_time': result.get('execution_time')
+                    }
+            else:
+                # Try to get error details
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get('error', f'HTTP {response.status_code}')
+                except:
+                    error_msg = f'HTTP {response.status_code}: {response.text}'
+                
+                return {
+                    'success': False,
+                    'result': None,
+                    'error': f"Server error: {error_msg}",
+                    'status_code': response.status_code,
+                    'agent_id': agent_id
+                }
+        
+        except requests.exceptions.ConnectionError:
+            raise ConnectionError(
+                f"Cannot connect to local server at {self.local_server_url}. "
+                "Make sure the server is running with 'runagent serve'"
+            )
+        except requests.exceptions.Timeout:
+            return {
+                'success': False,
+                'result': None,
+                'error': "Request timed out. Agent execution took too long.",
+                'agent_id': agent_id
+            }
+        except Exception as e:
+            return {
+                'success': False,
+                'result': None,
+                'error': f"HTTP request failed: {str(e)}",
+                'agent_id': agent_id
+            }
+    
+    def check_server_status(self) -> t.Dict[str, t.Any]:
+        """
+        Check if local server is running and get its status
+        
+        Returns:
+            Server status information
+        """
+        try:
+            response = requests.get(f"{self.local_server_url}/health", timeout=5)
+            if response.status_code == 200:
+                return {
+                    'running': True,
+                    'url': self.local_server_url,
+                    'status': response.json()
+                }
+            else:
+                return {
+                    'running': False,
+                    'error': f'Server returned HTTP {response.status_code}'
+                }
+        except requests.exceptions.ConnectionError:
+            return {
+                'running': False,
+                'error': 'Server not reachable'
+            }
+        except Exception as e:
+            return {
+                'running': False,
+                'error': str(e)
+            }
+    
+    def run_agent_direct(self, agent_id: str, input_data: t.Dict[str, t.Any]) -> t.Dict[str, t.Any]:
+        """
+        Run agent directly (bypass HTTP server) - for SDK use
+        
+        This method runs the agent directly in the same process,
+        not through the HTTP server.
+        """
+        return self.client.run_agent(agent_id, input_data)
+    
+    def delete_agent(self, agent_id: str) -> t.Dict[str, t.Any]:
+        """Delete a local agent"""
+        return self.client.delete_agent(agent_id)
+    
+    def get_capacity_info(self) -> t.Dict[str, t.Any]:
+        """Get local database capacity information"""
+        return self.client.get_capacity_info()
+    
+    def cleanup_old_records(self, days_old: int = 30) -> t.Dict[str, t.Any]:
+        """Clean up old database records"""
+        return self.client.cleanup_old_runs(days_old)
+    
+    def get_database_stats(self) -> t.Dict[str, t.Any]:
+        """Get database statistics"""
+        return self.client.get_database_stats()
+    
+    def start_server(self, port: int = 8450, host: str = "127.0.0.1", debug: bool = False):
+        """Start local FastAPI server"""
+        from ...server.local_server import LocalServer
+        server = LocalServer(port=port, host=host)
+        server.start(debug=debug)
+    
+    def _detect_framework(self, folder_path: Path) -> str:
+        """Auto-detect framework from project files"""
+        framework_keywords = {
+            'langgraph': ['langgraph', 'StateGraph', 'Graph'],
+            'langchain': ['langchain', 'ConversationChain', 'AgentExecutor'],
+            'llamaindex': ['llama_index', 'VectorStoreIndex', 'QueryEngine']
+        }
+        
+        for file_to_check in ['main.py', 'agent.py']:
+            file_path = folder_path / file_to_check
+            if file_path.exists():
+                try:
+                    content = file_path.read_text().lower()
+                    for framework, keywords in framework_keywords.items():
+                        if any(keyword.lower() in content for keyword in keywords):
+                            return framework
+                except:
+                    continue
+        
+        # Check requirements.txt
+        req_file = folder_path / 'requirements.txt'
+        if req_file.exists():
+            try:
+                content = req_file.read_text().lower()
+                for framework, keywords in framework_keywords.items():
+                    if any(keyword.lower() in content for keyword in keywords):
+                        return framework
+            except:
+                pass
+        
+        return 'unknown'
\ No newline at end of file
diff --git a/runagent/client/deployment/remote.py b/runagent/client/deployment/remote.py
new file mode 100644
index 0000000..cb6a3d0
--- /dev/null
+++ b/runagent/client/deployment/remote.py
@@ -0,0 +1,160 @@
+"""
+Remote deployment management.
+"""
+
+import typing as t
+from pathlib import Path
+
+from ..rest_client import RestClient
+from ..exceptions import ValidationError, AuthenticationError
+
+
+class RemoteDeployment:
+    """Manage remote agent deployments"""
+    
+    def __init__(self, config):
+        """
+        Initialize remote deployment manager.
+        
+        Args:
+            config: SDK configuration object
+        """
+        self.config = config
+        self.client = RestClient(
+            api_url=config.base_url,
+            api_key=config.api_key
+        )
+    
+    def deploy_agent(
+        self,
+        folder_path: str,
+        framework: t.Optional[str] = None,
+        config: t.Optional[t.Dict[str, t.Any]] = None
+    ) -> t.Dict[str, t.Any]:
+        """
+        Deploy an agent remotely (upload + start).
+        
+        Args:
+            folder_path: Path to agent folder
+            framework: Framework type (auto-detected if None)
+            config: Optional deployment configuration
+            
+        Returns:
+            Deployment result
+        """
+        folder_path = Path(folder_path)
+        if not folder_path.exists():
+            raise ValidationError(f"Folder not found: {folder_path}")
+        
+        # Auto-detect framework if not provided
+        if not framework:
+            framework = self._detect_framework(folder_path)
+        
+        metadata = {"framework": framework}
+        
+        return self.client.deploy_agent(
+            folder_path=str(folder_path),
+            metadata=metadata
+        )
+    
+    def upload_agent(
+        self,
+        folder_path: str,
+        framework: t.Optional[str] = None
+    ) -> t.Dict[str, t.Any]:
+        """
+        Upload an agent without starting it.
+        
+        Args:
+            folder_path: Path to agent folder
+            framework: Framework type (auto-detected if None)
+            
+        Returns:
+            Upload result
+        """
+        folder_path = Path(folder_path)
+        if not folder_path.exists():
+            raise ValidationError(f"Folder not found: {folder_path}")
+        
+        # Auto-detect framework if not provided
+        if not framework:
+            framework = self._detect_framework(folder_path)
+        
+        metadata = {"framework": framework}
+        
+        return self.client.upload_agent(
+            folder_path=str(folder_path),
+            metadata=metadata
+        )
+    
+    def start_agent(
+        self,
+        agent_id: str,
+        config: t.Optional[t.Dict[str, t.Any]] = None
+    ) -> t.Dict[str, t.Any]:
+        """
+        Start a previously uploaded agent.
+        
+        Args:
+            agent_id: ID of uploaded agent
+            config: Optional deployment configuration
+            
+        Returns:
+            Start result
+        """
+        return self.client.start_agent(agent_id, config or {})
+    
+    def get_agent_info(self, agent_id: str) -> t.Dict[str, t.Any]:
+        """Get information about a remote agent"""
+        return self.client.get_agent_status(agent_id)
+    
+    def run_agent(self, agent_id: str, input_data: t.Dict[str, t.Any]) -> t.Dict[str, t.Any]:
+        """Run a remote agent"""
+        # This would need to be implemented in RestClient
+        # For now, return a placeholder
+        return {
+            "success": False,
+            "error": "Remote agent execution not yet implemented"
+        }
+    
+    def delete_agent(self, agent_id: str) -> t.Dict[str, t.Any]:
+        """Delete a remote agent"""
+        # This would need to be implemented in RestClient
+        # For now, return a placeholder
+        return {
+            "success": False,
+            "error": "Remote agent deletion not yet implemented"
+        }
+    
+    def _detect_framework(self, folder_path: Path) -> str:
+        """Auto-detect framework from project files"""
+        # Same logic as LocalDeployment
+        framework_keywords = {
+            'langgraph': ['langgraph', 'StateGraph', 'Graph'],
+            'langchain': ['langchain', 'ConversationChain', 'AgentExecutor'],
+            'llamaindex': ['llama_index', 'VectorStoreIndex', 'QueryEngine']
+        }
+        
+        for file_to_check in ['main.py', 'agent.py']:
+            file_path = folder_path / file_to_check
+            if file_path.exists():
+                try:
+                    content = file_path.read_text().lower()
+                    for framework, keywords in framework_keywords.items():
+                        if any(keyword.lower() in content for keyword in keywords):
+                            return framework
+                except:
+                    continue
+        
+        # Check requirements.txt
+        req_file = folder_path / 'requirements.txt'
+        if req_file.exists():
+            try:
+                content = req_file.read_text().lower()
+                for framework, keywords in framework_keywords.items():
+                    if any(keyword.lower() in content for keyword in keywords):
+                        return framework
+            except:
+                pass
+        
+        return 'unknown'
diff --git a/runagent/client/exceptions.py b/runagent/client/exceptions.py
index 4ef5461..bc70249 100644
--- a/runagent/client/exceptions.py
+++ b/runagent/client/exceptions.py
@@ -1,33 +1,44 @@
 """
 RunAgent SDK Custom exceptions.
 """
+
 import typing as t
 
-class ClientError(Exception):
-    """Base exception for client errors."""
-    def __init__(self, message: str, status_code: t.Optional[int] = None, response: t.Optional[t.Any] = None):
+
+class RunAgentError(Exception):
+    """Base exception for all RunAgent SDK errors."""
+    
+    def __init__(self, message: str, details: t.Optional[t.Dict[str, t.Any]] = None):
         self.message = message
-        self.status_code = status_code
-        self.response = response
+        self.details = details or {}
         super().__init__(self.message)
 
 
-class ServerError(Exception):
-    """Exception for server errors."""
+class AuthenticationError(RunAgentError):
+    """Exception for authentication and authorization errors."""
     pass
 
 
-class ConnectionError(Exception):
-    """Exception for connection errors."""
+class ValidationError(RunAgentError):
+    """Exception for input validation errors."""
     pass
 
 
-class AuthenticationError(ClientError):
-    """Exception for authentication errors."""
+class ConnectionError(RunAgentError):
+    """Exception for network and connection errors."""
     pass
 
 
-class ValidationError(ClientError):
-    """Exception for validation errors."""
+class ServerError(RunAgentError):
+    """Exception for server-side errors."""
     pass
 
+
+class TemplateError(RunAgentError):
+    """Exception for template-related errors."""
+    pass
+
+
+class DeploymentError(RunAgentError):
+    """Exception for deployment-related errors."""
+    pass
diff --git a/runagent/client/sdk.py b/runagent/client/sdk.py
new file mode 100644
index 0000000..e6ba601
--- /dev/null
+++ b/runagent/client/sdk.py
@@ -0,0 +1,571 @@
+# runagent/client/sdk.py (UPDATED - Fix run_agent error handling)
+"""
+Main SDK class that provides all RunAgent functionality.
+"""
+
+import os
+import time
+import typing as t
+from pathlib import Path
+
+from .config import SDKConfig
+from .template_manager import TemplateManager
+from .deployment import LocalDeployment, RemoteDeployment
+from .agents import AgentManager
+from .exceptions import ValidationError, AuthenticationError
+
+
+class RunAgentSDK:
+    """
+    Main RunAgent SDK class providing all functionality for agent deployment and management.
+    """
+    
+    def __init__(
+        self,
+        api_key: t.Optional[str] = None,
+        base_url: t.Optional[str] = None,
+        config_file: t.Optional[str] = None
+    ):
+        """
+        Initialize the RunAgent SDK.
+        
+        Args:
+            api_key: API key for authentication (can also be set via RUNAGENT_API_KEY env var)
+            base_url: Base URL for the RunAgent service (can also be set via RUNAGENT_BASE_URL env var)
+            config_file: Path to configuration file (optional)
+        """
+        # Initialize configuration
+        self.config = SDKConfig(
+            api_key=api_key,
+            base_url=base_url,
+            config_file=config_file
+        )
+        
+        # Initialize managers
+        self.templates = TemplateManager()
+        self.local = LocalDeployment(self.config)
+        self.remote = RemoteDeployment(self.config) 
+        self.agents = AgentManager(self.config)
+        
+        # Validate configuration on initialization
+        self._validate_basic_setup()
+    
+    def _validate_basic_setup(self):
+        """Validate basic SDK setup"""
+        # Check if we can access template repository
+        try:
+            self.templates.check_connectivity()
+        except Exception as e:
+            # Non-fatal warning for template connectivity
+            pass
+    
+    # Configuration Methods
+    def configure(
+        self,
+        api_key: t.Optional[str] = None,
+        base_url: t.Optional[str] = None,
+        save: bool = True
+    ) -> bool:
+        """
+        Configure the SDK with authentication and server details.
+        
+        Args:
+            api_key: API key for authentication
+            base_url: Base URL for the RunAgent service
+            save: Whether to save configuration to disk
+            
+        Returns:
+            True if configuration is successful
+            
+        Raises:
+            AuthenticationError: If authentication fails
+        """
+        return self.config.setup(
+            api_key=api_key,
+            base_url=base_url,
+            save=save,
+            validate_auth=True
+        )
+    
+    def configure_basic(
+        self,
+        api_key: t.Optional[str] = None,
+        base_url: t.Optional[str] = None,
+        save: bool = True
+    ) -> bool:
+        """
+        Configure the SDK without validating authentication (for testing/development).
+        
+        Args:
+            api_key: API key for authentication
+            base_url: Base URL for the RunAgent service
+            save: Whether to save configuration to disk
+            
+        Returns:
+            True if configuration is successful
+        """
+        return self.config.setup(
+            api_key=api_key,
+            base_url=base_url,
+            save=save,
+            validate_auth=False
+        )
+    
+    def is_configured(self) -> bool:
+        """Check if SDK is properly configured"""
+        return self.config.is_configured()
+    
+    def get_config_status(self) -> t.Dict[str, t.Any]:
+        """Get detailed configuration status"""
+        return self.config.get_status()
+    
+    # Template Methods
+    def list_templates(self, framework: t.Optional[str] = None) -> t.Dict[str, t.List[str]]:
+        """
+        List available project templates.
+        
+        Args:
+            framework: Optional framework filter
+            
+        Returns:
+            Dictionary mapping framework names to template lists
+        """
+        return self.templates.list_available(framework_filter=framework)
+    
+    def get_template_info(self, framework: str, template: str) -> t.Optional[t.Dict[str, t.Any]]:
+        """
+        Get detailed information about a specific template.
+        
+        Args:
+            framework: Framework name (e.g., 'langchain', 'langgraph')
+            template: Template name (e.g., 'basic', 'advanced')
+            
+        Returns:
+            Template information dictionary or None if not found
+        """
+        return self.templates.get_info(framework, template)
+    
+    # Project Initialization Methods
+    def init_project(
+        self,
+        folder: str,
+        framework: str = "langchain",
+        template: str = "basic",
+        overwrite: bool = False
+    ) -> bool:
+        """
+        Initialize a new agent project.
+        
+        Args:
+            folder: Project folder name
+            framework: Framework to use (langchain, langgraph, llamaindex)
+            template: Template variant (basic, advanced)
+            overwrite: Whether to overwrite existing folder
+            
+        Returns:
+            True if initialization is successful
+            
+        Raises:
+            ValidationError: If parameters are invalid
+            FileExistsError: If folder exists and overwrite is False
+        """
+        return self.templates.init_project(
+            folder=folder,
+            framework=framework,
+            template=template,
+            overwrite=overwrite
+        )
+    
+    # Local Deployment Methods
+    def deploy_local(
+        self,
+        folder: str,
+        framework: t.Optional[str] = None,
+        replace_agent_id: t.Optional[str] = None
+    ) -> t.Dict[str, t.Any]:
+        """
+        Deploy an agent locally for testing.
+        
+        Args:
+            folder: Folder containing agent files
+            framework: Framework type (auto-detected if not specified)
+            replace_agent_id: Optional agent ID to replace (for capacity management)
+            
+        Returns:
+            Deployment result with agent_id and endpoint
+        """
+        return self.local.deploy_agent(
+            folder_path=folder,
+            framework=framework,
+            replace_agent_id=replace_agent_id
+        )
+    
+    def list_local_agents(self) -> t.List[t.Dict[str, t.Any]]:
+        """List all locally deployed agents"""
+        return self.local.list_agents()
+    
+    def get_local_capacity(self) -> t.Dict[str, t.Any]:
+        """Get local database capacity information"""
+        return self.local.get_capacity_info()
+    
+    def run_local_agent(self, agent_id: str, input_data: t.Dict[str, t.Any]) -> t.Dict[str, t.Any]:
+        """
+        Run a locally deployed agent via HTTP server.
+        
+        Args:
+            agent_id: ID of the agent to run
+            input_data: Input data for the agent
+            
+        Returns:
+            Agent execution result
+        """
+        return self.local.run_agent(agent_id, input_data)
+    
+    def run_local_agent_direct(self, agent_id: str, input_data: t.Dict[str, t.Any]) -> t.Dict[str, t.Any]:
+        """
+        Run a locally deployed agent directly (bypass HTTP server).
+        
+        Args:
+            agent_id: ID of the agent to run
+            input_data: Input data for the agent
+            
+        Returns:
+            Agent execution result
+        """
+        return self.local.run_agent_direct(agent_id, input_data)
+    
+    def start_local_server(
+        self,
+        port: int = 8450,
+        host: str = "127.0.0.1",
+        debug: bool = False
+    ) -> None:
+        """
+        Start the local FastAPI server for testing agents.
+        
+        Args:
+            port: Port to run server on
+            host: Host to bind to
+            debug: Enable debug mode
+        """
+        return self.local.start_server(port=port, host=host, debug=debug)
+    
+    # Remote Deployment Methods  
+    def deploy_remote(
+        self,
+        folder: str,
+        framework: t.Optional[str] = None,
+        config: t.Optional[t.Dict[str, t.Any]] = None
+    ) -> t.Dict[str, t.Any]:
+        """
+        Deploy an agent to the remote server (upload + start).
+        
+        Args:
+            folder: Folder containing agent files
+            framework: Framework type (auto-detected if not specified)
+            config: Optional deployment configuration
+            
+        Returns:
+            Deployment result with agent_id and endpoint
+            
+        Raises:
+            AuthenticationError: If not properly authenticated
+        """
+        self._require_authentication()
+        return self.remote.deploy_agent(
+            folder_path=folder,
+            framework=framework,
+            config=config
+        )
+    
+    def upload_agent(
+        self,
+        folder: str,
+        framework: t.Optional[str] = None
+    ) -> t.Dict[str, t.Any]:
+        """
+        Upload an agent to the remote server (without starting).
+        
+        Args:
+            folder: Folder containing agent files
+            framework: Framework type (auto-detected if not specified)
+            
+        Returns:
+            Upload result with agent_id
+            
+        Raises:
+            AuthenticationError: If not properly authenticated
+        """
+        self._require_authentication()
+        return self.remote.upload_agent(folder_path=folder, framework=framework)
+    
+    def start_remote_agent(
+        self,
+        agent_id: str,
+        config: t.Optional[t.Dict[str, t.Any]] = None
+    ) -> t.Dict[str, t.Any]:
+        """
+        Start a previously uploaded agent on the remote server.
+        
+        Args:
+            agent_id: ID of the uploaded agent
+            config: Optional deployment configuration
+            
+        Returns:
+            Start result with endpoint
+            
+        Raises:
+            AuthenticationError: If not properly authenticated
+        """
+        self._require_authentication()
+        return self.remote.start_agent(agent_id, config)
+    
+    # Agent Management Methods
+    def get_agent_info(self, agent_id: str, local: bool = True) -> t.Dict[str, t.Any]:
+        """
+        Get comprehensive information about an agent.
+        
+        Args:
+            agent_id: Agent identifier
+            local: Whether to check local or remote agents
+            
+        Returns:
+            Agent information dictionary
+        """
+        if local:
+            return self.local.get_agent_info(agent_id)
+        else:
+            self._require_authentication()
+            return self.remote.get_agent_info(agent_id)
+    
+    def delete_agent(self, agent_id: str, local: bool = True) -> t.Dict[str, t.Any]:
+        """
+        Delete an agent (files only for local, full deletion for remote).
+        
+        Args:
+            agent_id: Agent identifier
+            local: Whether to delete local or remote agent
+            
+        Returns:
+            Deletion result
+        """
+        if local:
+            return self.local.delete_agent(agent_id)
+        else:
+            self._require_authentication() 
+            return self.remote.delete_agent(agent_id)
+    
+    # Utility Methods
+    def run_agent(
+        self,
+        agent_id: str,
+        message: t.Optional[str] = None,
+        messages: t.Optional[t.List[t.Dict[str, str]]] = None,
+        config: t.Optional[t.Dict[str, t.Any]] = None,
+        local: bool = True
+    ) -> t.Dict[str, t.Any]:
+        """
+        Run an agent with a message or conversation.
+        
+        Args:
+            agent_id: Agent identifier
+            message: Simple message string
+            messages: List of message objects with 'role' and 'content'
+            config: Optional configuration
+            local: Whether to run locally or remotely
+            
+        Returns:
+            Agent execution result with proper error handling
+        """
+        # Prepare input data
+        if messages:
+            input_data = {"messages": messages}
+        elif message:
+            input_data = {"messages": [{"role": "user", "content": message}]}
+        else:
+            raise ValidationError("Either 'message' or 'messages' must be provided")
+        
+        if config:
+            input_data["config"] = config
+        
+        # Run the agent
+        if local:
+            result = self.local.run_agent(agent_id, input_data)
+            
+            # Enhanced error handling for local agents
+            if not result.get('success'):
+                error_msg = result.get('error', 'Unknown error')
+                
+                # If error is None or empty, try to get more details
+                if not error_msg or error_msg == 'None':
+                    # Try to get agent info to see what's wrong
+                    agent_info = self.get_agent_info(agent_id, local=True)
+                    if agent_info.get('success'):
+                        agent_data = agent_info['agent_info']
+                        if not agent_data.get('deployment_exists'):
+                            result['error'] = f"Agent {agent_id} deployment files not found"
+                        elif not agent_data.get('source_exists'):
+                            result['error'] = f"Agent {agent_id} source files not found"
+                        elif agent_data.get('status') == 'error':
+                            result['error'] = f"Agent {agent_id} is in error state"
+                        else:
+                            result['error'] = f"Agent {agent_id} execution failed with unknown error"
+                    else:
+                        result['error'] = f"Agent {agent_id} not found in database"
+                
+                # Add suggestions based on error type
+                result['suggestions'] = self._get_error_suggestions(result['error'])
+            
+            return result
+        else:
+            self._require_authentication()
+            return self.remote.run_agent(agent_id, input_data)
+    
+    def _get_error_suggestions(self, error_msg: str) -> t.List[str]:
+        """Get suggestions based on error message"""
+        suggestions = []
+        
+        if 'not found' in error_msg.lower():
+            suggestions.append("Check if the agent ID is correct")
+            suggestions.append("Use sdk.list_local_agents() to see available agents")
+        
+        if 'deployment files not found' in error_msg.lower():
+            suggestions.append("Try redeploying the agent")
+            suggestions.append("Check if the deployment directory exists")
+        
+        if 'error state' in error_msg.lower():
+            suggestions.append("Check agent logs for details")
+            suggestions.append("Try redeploying the agent")
+        
+        if 'execution failed' in error_msg.lower():
+            suggestions.append("Check if all dependencies are installed")
+            suggestions.append("Verify the agent's main.py file is valid")
+            suggestions.append("Check environment variables (.env file)")
+        
+        return suggestions
+    
+    def validate_agent(self, folder: str) -> t.Tuple[bool, t.Dict[str, t.Any]]:
+        """
+        Validate an agent project structure.
+        
+        Args:
+            folder: Path to agent folder
+            
+        Returns:
+            Tuple of (is_valid, validation_details)
+        """
+        return self.agents.validate_agent(folder)
+    
+    def detect_framework(self, folder: str) -> str:
+        """
+        Auto-detect the framework used in an agent project.
+        
+        Args:
+            folder: Path to agent folder
+            
+        Returns:
+            Detected framework name
+        """
+        return self.agents.detect_framework(folder)
+    
+    # Database and Server Management
+    def cleanup_local_database(self, days_old: int = 30) -> t.Dict[str, t.Any]:
+        """
+        Clean up old local database records.
+        
+        Args:
+            days_old: Delete records older than this many days
+            
+        Returns:
+            Cleanup result
+        """
+        return self.local.cleanup_old_records(days_old)
+    
+    def get_local_stats(self) -> t.Dict[str, t.Any]:
+        """Get local database statistics"""
+        return self.local.get_database_stats()
+    
+    # Debug Methods
+    def debug_agent(self, agent_id: str, local: bool = True) -> t.Dict[str, t.Any]:
+        """
+        Debug an agent to identify issues.
+        
+        Args:
+            agent_id: Agent identifier
+            local: Whether to debug local or remote agent
+            
+        Returns:
+            Debug information
+        """
+        if not local:
+            return {"error": "Remote agent debugging not yet implemented"}
+        
+        # Get agent info
+        agent_info = self.get_agent_info(agent_id, local=True)
+        if not agent_info.get('success'):
+            return {"error": f"Agent {agent_id} not found"}
+        
+        agent_data = agent_info['agent_info']
+        debug_info = {
+            "agent_id": agent_id,
+            "status": agent_data.get('status'),
+            "framework": agent_data.get('framework'),
+            "deployment_exists": agent_data.get('deployment_exists'),
+            "source_exists": agent_data.get('source_exists'),
+            "deployment_path": agent_data.get('deployment_path'),
+            "source_path": agent_data.get('folder_path'),
+            "stats": agent_data.get('stats', {}),
+            "issues": []
+        }
+        
+        # Check for common issues
+        if not agent_data.get('deployment_exists'):
+            debug_info['issues'].append("Deployment files missing")
+        
+        if not agent_data.get('source_exists'):
+            debug_info['issues'].append("Source files missing")
+        
+        if agent_data.get('stats', {}).get('success_rate', 0) == 0:
+            debug_info['issues'].append("Agent has never run successfully")
+        
+        # Try to run the agent directly and capture the error
+        try:
+            result = self.run_local_agent_direct(agent_id, {
+                "messages": [{"role": "user", "content": "test"}]
+            })
+            if not result.get('success'):
+                debug_info['last_error'] = result.get('error')
+                debug_info['traceback'] = result.get('traceback')
+        except Exception as e:
+            debug_info['direct_run_error'] = str(e)
+        
+        return debug_info
+    
+    # Private Helper Methods
+    def _require_authentication(self):
+        """Ensure SDK is properly authenticated for remote operations"""
+        if not self.config.is_authenticated():
+            raise AuthenticationError(
+                "Remote operations require authentication. "
+                "Call sdk.configure(api_key='your-key') first."
+            )
+    
+    def _validate_folder_path(self, folder: str) -> Path:
+        """Validate and return folder path"""
+        folder_path = Path(folder)
+        if not folder_path.exists():
+            raise ValidationError(f"Folder not found: {folder}")
+        return folder_path
+    
+    # Context Manager Support
+    def __enter__(self):
+        """Enter context manager"""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exit context manager - cleanup if needed"""
+        pass
+    
+    # String representation
+    def __repr__(self):
+        return f"RunAgentSDK(configured={self.is_configured()})"
\ No newline at end of file
diff --git a/runagent/client/template_manager.py b/runagent/client/template_manager.py
new file mode 100644
index 0000000..075a0ba
--- /dev/null
+++ b/runagent/client/template_manager.py
@@ -0,0 +1,167 @@
+"""
+Template management for the SDK.
+"""
+
+import typing as t
+from pathlib import Path
+
+from ..constants import (
+    TEMPLATE_REPO_URL,
+    TEMPLATE_BRANCH, 
+    TEMPLATE_PREPATH
+)
+from .template_downloader import TemplateDownloader
+from .exceptions import ValidationError
+
+
+class TemplateManager:
+    """Manage project templates"""
+    
+    def __init__(self):
+        """Initialize template manager"""
+        self.downloader = TemplateDownloader(
+            repo_url=TEMPLATE_REPO_URL,
+            branch=TEMPLATE_BRANCH
+        )
+    
+    def check_connectivity(self) -> bool:
+        """Check if template repository is accessible"""
+        try:
+            self.list_available()
+            return True
+        except Exception:
+            return False
+    
+    def list_available(self, framework_filter: t.Optional[str] = None) -> t.Dict[str, t.List[str]]:
+        """
+        List available templates.
+        
+        Args:
+            framework_filter: Optional framework to filter by
+            
+        Returns:
+            Dictionary mapping framework names to template lists
+        """
+        try:
+            templates = self.downloader.list_available_templates(TEMPLATE_PREPATH)
+            
+            if framework_filter:
+                if framework_filter in templates:
+                    return {framework_filter: templates[framework_filter]}
+                else:
+                    return {}
+            
+            return templates
+        except Exception as e:
+            raise ValidationError(f"Failed to fetch templates: {str(e)}")
+    
+    def get_info(self, framework: str, template: str) -> t.Optional[t.Dict[str, t.Any]]:
+        """
+        Get detailed information about a template.
+        
+        Args:
+            framework: Framework name
+            template: Template name
+            
+        Returns:
+            Template information or None if not found
+        """
+        try:
+            return self.downloader.get_template_info(TEMPLATE_PREPATH, framework, template)
+        except Exception:
+            return None
+    
+    def init_project(
+        self,
+        folder: str,
+        framework: str,
+        template: str,
+        overwrite: bool = False
+    ) -> bool:
+        """
+        Initialize a new project from template.
+        
+        Args:
+            folder: Project folder name
+            framework: Framework to use
+            template: Template variant
+            overwrite: Whether to overwrite existing folder
+            
+        Returns:
+            True if successful
+            
+        Raises:
+            ValidationError: If template is invalid
+            FileExistsError: If folder exists and overwrite is False
+        """
+        # Validate template exists
+        available_templates = self.list_available()
+        if framework not in available_templates:
+            raise ValidationError(
+                f"Framework '{framework}' not available. "
+                f"Available: {list(available_templates.keys())}"
+            )
+        
+        if template not in available_templates[framework]:
+            raise ValidationError(
+                f"Template '{template}' not available for {framework}. "
+                f"Available: {available_templates[framework]}"
+            )
+        
+        # Check folder existence
+        folder_path = Path(folder)
+        if folder_path.exists() and any(folder_path.iterdir()):
+            if not overwrite:
+                raise FileExistsError(
+                    f"Folder '{folder}' already exists and is not empty. "
+                    "Use overwrite=True to force initialization."
+                )
+        
+        # Create folder
+        folder_path.mkdir(parents=True, exist_ok=True)
+        
+        try:
+            # Download template
+            self.downloader.download_template(
+                prepath=TEMPLATE_PREPATH,
+                framework=framework,
+                template=template,
+                target_folder=str(folder_path)
+            )
+            
+            # Create project configuration
+            self._create_project_config(folder_path, framework, template)
+            
+            return True
+            
+        except Exception as e:
+            # Clean up on failure
+            if folder_path.exists():
+                import shutil
+                shutil.rmtree(folder_path)
+            raise ValidationError(f"Project initialization failed: {str(e)}")
+    
+    def _create_project_config(self, folder_path: Path, framework: str, template: str):
+        """Create project configuration file"""
+        import time
+        from ..utils.config import Config
+        
+        config_content = {
+            "agent_name": folder_path.name,
+            "framework": framework,
+            "template": template,
+            "version": "0.1.0",
+            "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+            "template_source": {
+                "repo_url": TEMPLATE_REPO_URL,
+                "branch": TEMPLATE_BRANCH,
+                "path": f"{TEMPLATE_PREPATH}/{framework}/{template}"
+            },
+            "architecture": {
+                "main_file": "main.py",
+                "agent_file": "agent.py",
+                "entry_point": "run"
+            }
+        }
+        
+        Config.create_config(str(folder_path), config_content)
diff --git a/runagent/constants.py b/runagent/constants.py
index 9c6cfd7..fe362a3 100644
--- a/runagent/constants.py
+++ b/runagent/constants.py
@@ -21,8 +21,8 @@
 # Local Configuration
 LOCAL_CACHE_DIRECTORY_PATH = "~/.runagent"
 USER_DATA_FILE_NAME = "user_data.json"
-# DEFAULT_BASE_URL = "http://localhost:8330/"
 DEFAULT_BASE_URL = "http://52.237.88.147:8330/"
+# DEFAULT_BASE_URL = "http://52.237.88.147:8330/"
 AGENT_CONFIG_FILE_NAME = "runagent.config.json"
 
 # Setup cache directory
diff --git a/runagent/test/debug_sdk.py b/runagent/test/debug_sdk.py
new file mode 100644
index 0000000..bd395ba
--- /dev/null
+++ b/runagent/test/debug_sdk.py
@@ -0,0 +1,81 @@
+from runagent import RunAgent
+
+def debug_agent_issue():
+    """Debug the agent execution issue"""
+    
+    print("🔍 DEBUGGING AGENT EXECUTION ISSUE")
+    print("=" * 50)
+    
+    sdk = RunAgent()
+    agent_id = "1208924a"
+    
+    # 1. Check if agent exists
+    print("1. Checking agent info...")
+    agent_info = sdk.get_agent_info(agent_id)
+    if agent_info.get('success'):
+        info = agent_info['agent_info']
+        print(f"   ✅ Agent found: {agent_id}")
+        print(f"   📊 Status: {info.get('status')}")
+        print(f"   🔧 Framework: {info.get('framework')}")
+        print(f"   📁 Deployment exists: {info.get('deployment_exists')}")
+        print(f"   📄 Source exists: {info.get('source_exists')}")
+        print(f"   📈 Success rate: {info.get('stats', {}).get('success_rate', 0)}%")
+    else:
+        print(f"   ❌ Agent not found: {agent_info.get('error')}")
+        return
+    
+    # 2. Try direct execution (bypass HTTP)
+    print("\n2. Testing direct execution (bypass HTTP server)...")
+    try:
+        result = sdk.run_local_agent_direct(agent_id, {
+            "messages": [{"role": "user", "content": "test direct"}]
+        })
+        print(f"   📤 Direct result: {result}")
+        
+        if result.get('success'):
+            print("   ✅ Direct execution works!")
+        else:
+            print(f"   ❌ Direct execution failed: {result.get('error')}")
+            if result.get('traceback'):
+                print(f"   📋 Traceback: {result.get('traceback')}")
+    except Exception as e:
+        print(f"   ❌ Direct execution exception: {e}")
+    
+    # 3. Try HTTP execution
+    print("\n3. Testing HTTP execution (via server)...")
+    try:
+        result = sdk.run_local_agent(agent_id, {
+            "messages": [{"role": "user", "content": "test http"}]
+        })
+        print(f"   📤 HTTP result: {result}")
+        
+        if result.get('success'):
+            print("   ✅ HTTP execution works!")
+        else:
+            print(f"   ❌ HTTP execution failed: {result.get('error')}")
+            suggestions = result.get('suggestions', [])
+            if suggestions:
+                print("   💡 Suggestions:")
+                for suggestion in suggestions:
+                    print(f"      - {suggestion}")
+    except Exception as e:
+        print(f"   ❌ HTTP execution exception: {e}")
+    
+    # 4. Use debug method
+    print("\n4. Running debug analysis...")
+    debug_info = sdk.debug_agent(agent_id)
+    print(f"   🔍 Debug info: {debug_info}")
+    
+    # 5. Check server status
+    print("\n5. Checking server status...")
+    server_status = sdk.local.check_server_status()
+    print(f"   🌐 Server running: {server_status.get('running')}")
+    if not server_status.get('running'):
+        print(f"   ❌ Server error: {server_status.get('error')}")
+    
+    print("\n" + "=" * 50)
+    print("🔍 Debug complete!")
+
+
+if __name__ == "__main__":
+    debug_agent_issue()
\ No newline at end of file
diff --git a/runagent/test/sdk_test.py b/runagent/test/sdk_test.py
new file mode 100644
index 0000000..30a69bc
--- /dev/null
+++ b/runagent/test/sdk_test.py
@@ -0,0 +1,38 @@
+from runagent import RunAgent
+sdk = RunAgent()
+
+# print(sdk.list_templates())
+# print(sdk.get_template_info("langchain", "basic"))
+# sdk.init_project(folder="sdk-agent", framework="langchain")
+
+# sdk.deploy_local(folder="/home/riamdriad5/runagent/runagent/sdk-agent")
+
+# print(sdk.list_local_agents())
+
+
+
+print(sdk.run_agent(agent_id="d6594457", message="meow", local=True))
+
+
+
+# # Local Deployment
+# sdk.deploy_local(folder="agent")
+# sdk.list_local_agents()
+# sdk.get_local_capacity()
+# sdk.run_local_agent(agent_id="123", input_data={})
+# sdk.start_local_server(port=8450)
+
+# # Remote Deployment
+# sdk.deploy_remote(folder="agent")
+# sdk.upload_agent(folder="agent")
+# sdk.start_remote_agent(agent_id="123")
+
+# # Agent Management
+# sdk.get_agent_info(agent_id="123", local=True)
+# sdk.validate_agent(folder="agent")
+# sdk.detect_framework(folder="agent")
+# sdk.run_agent(agent_id="123", message="Hello")
+
+# # Utilities
+# sdk.cleanup_local_database(days_old=30)
+# sdk.get_local_stats()
\ No newline at end of file
diff --git a/runagent/test/test_http.py b/runagent/test/test_http.py
new file mode 100644
index 0000000..1bc0708
--- /dev/null
+++ b/runagent/test/test_http.py
@@ -0,0 +1,62 @@
+import requests
+import json
+
+def test_http_response():
+    """Test the HTTP response format directly"""
+    
+    print("🧪 TESTING HTTP RESPONSE FORMAT")
+    print("=" * 50)
+    
+    url = "http://127.0.0.1:8450/agents/1208924a/run"
+    
+    input_data = {
+        "messages": [{"role": "user", "content": "test http format"}]
+    }
+    
+    print(f"📤 Sending request to: {url}")
+    print(f"📋 Input data: {json.dumps(input_data, indent=2)}")
+    
+    try:
+        response = requests.post(
+            url,
+            json=input_data,
+            headers={'Content-Type': 'application/json'},
+            timeout=30
+        )
+        
+        print(f"\n📥 Response status: {response.status_code}")
+        print(f"📥 Response headers: {dict(response.headers)}")
+        
+        if response.status_code == 200:
+            result = response.json()
+            print(f"📥 Response JSON (formatted):")
+            print(json.dumps(result, indent=2))
+            
+            # Analyze the response structure
+            print(f"\n🔍 Response Analysis:")
+            print(f"   - Type: {type(result)}")
+            print(f"   - Keys: {list(result.keys()) if isinstance(result, dict) else 'Not a dict'}")
+            
+            if isinstance(result, dict):
+                print(f"   - success: {result.get('success')} ({type(result.get('success'))})")
+                print(f"   - result: {type(result.get('result'))}")
+                print(f"   - error: {result.get('error')} ({type(result.get('error'))})")
+                print(f"   - agent_id: {result.get('agent_id')}")
+                
+                if result.get('result'):
+                    result_content = result['result']
+                    print(f"   - result.type: {result_content.get('type')}")
+                    print(f"   - result.content: {result_content.get('content', '')[:100]}...")
+        else:
+            print(f"❌ HTTP Error: {response.status_code}")
+            print(f"📋 Response text: {response.text}")
+    
+    except requests.exceptions.ConnectionError:
+        print("❌ Connection failed. Is the server running?")
+        print("💡 Start server with: runagent serve")
+    except Exception as e:
+        print(f"❌ Request failed: {e}")
+
+
+if __name__ == "__main__":
+    test_http_response()
\ No newline at end of file
diff --git a/sdk-agent/__init__.py b/sdk-agent/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/sdk-agent/agent.py b/sdk-agent/agent.py
new file mode 100644
index 0000000..5094b47
--- /dev/null
+++ b/sdk-agent/agent.py
@@ -0,0 +1,55 @@
+from typing import Dict, Any
+from langchain_openai import ChatOpenAI
+from langchain.chains import ConversationChain
+from langchain.memory import ConversationBufferMemory
+from langchain_core.messages import HumanMessage, AIMessage
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+class LangChainBasicAgent:
+    """Basic LangChain agent with conversation memory"""
+    
+    def __init__(self, config: Dict[str, Any] = None):
+        self.config = config or {}
+        self.llm = ChatOpenAI(
+            temperature=self.config.get("temperature", 0.7),
+            model=self.config.get("model", "gpt-4o-mini"),
+            api_key=os.getenv("OPENAI_API_KEY")
+        )
+        self.memory = ConversationBufferMemory()
+        self.conversation = ConversationChain(
+            llm=self.llm,
+            memory=self.memory,
+            verbose=self.config.get("verbose", False)
+        )
+    
+    def process_message(self, message: str) -> str:
+        """Process a single message and return response"""
+        try:
+            response = self.conversation.predict(input=message)
+            return response
+        except Exception as e:
+            raise Exception(f"Error processing message: {str(e)}")
+    
+    def process_messages(self, messages: list) -> str:
+        """Process a list of messages and return the final response"""
+        if not messages:
+            return "No messages provided"
+        
+        # Add previous messages to memory (except the last one)
+        for msg in messages[:-1]:
+            if msg.get("role") == "user":
+                self.memory.chat_memory.add_user_message(msg["content"])
+            elif msg.get("role") == "assistant":
+                self.memory.chat_memory.add_ai_message(msg["content"])
+        
+        # Process the last message
+        last_message = messages[-1]["content"]
+        return self.process_message(last_message)
+    
+    def get_conversation_history(self) -> list:
+        """Get the conversation history"""
+        return self.memory.chat_memory.messages
\ No newline at end of file
diff --git a/sdk-agent/main.py b/sdk-agent/main.py
new file mode 100644
index 0000000..678b515
--- /dev/null
+++ b/sdk-agent/main.py
@@ -0,0 +1,71 @@
+from typing import Dict, Any
+import time
+from agent import LangChainBasicAgent
+
+def run(input_data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Main entry point for the LangChain Basic agent
+    
+    Args:
+        input_data: Dictionary containing:
+            - messages: List of message objects with 'role' and 'content'
+            - config: Optional configuration parameters
+            
+    Returns:
+        Dictionary with result, errors, and success status
+    """
+    start_time = time.time()
+    
+    try:
+        # Extract configuration
+        config = input_data.get("config", {})
+        messages = input_data.get("messages", [])
+        
+        if not messages:
+            return {
+                "result": {
+                    "type": "string",
+                    "content": "No messages provided",
+                    "metadata": {
+                        "execution_time": time.time() - start_time
+                    }
+                },
+                "errors": ["No messages provided"],
+                "success": False
+            }
+        
+        # Initialize agent
+        agent = LangChainBasicAgent(config)
+        
+        # Process messages
+        response = agent.process_messages(messages)
+        
+        # Calculate execution time
+        execution_time = time.time() - start_time
+        
+        return {
+            "result": {
+                "type": "string",
+                "content": response,
+                "metadata": {
+                    "model_used": config.get("model", "gpt-4"),
+                    "framework": "langchain",
+                    "template": "basic",
+                    "execution_time": execution_time,
+                    "conversation_length": len(messages)
+                }
+            },
+            "errors": [],
+            "success": True
+        }
+        
+    except Exception as e:
+        execution_time = time.time() - start_time
+        return {
+            "result": None,
+            "errors": [str(e)],
+            "success": False,
+            "metadata": {
+                "execution_time": execution_time
+            }
+        }
\ No newline at end of file
diff --git a/sdk-agent/requirements.txt b/sdk-agent/requirements.txt
new file mode 100644
index 0000000..ac267f8
--- /dev/null
+++ b/sdk-agent/requirements.txt
@@ -0,0 +1,4 @@
+langchain==0.1.0
+langchain-openai==0.0.5
+openai==1.12.0
+python-dotenv==1.0.0
\ No newline at end of file
diff --git a/sdk-agent/runagent.config.json b/sdk-agent/runagent.config.json
new file mode 100644
index 0000000..abc06d3
--- /dev/null
+++ b/sdk-agent/runagent.config.json
@@ -0,0 +1,17 @@
+{
+  "agent_name": "sdk-agent",
+  "framework": "langchain",
+  "template": "basic",
+  "version": "0.1.0",
+  "created_at": "2025-06-17 18:14:15",
+  "template_source": {
+    "repo_url": "https://github.com/runagent-dev/runagent.git",
+    "branch": "radeen/cli-update",
+    "path": "templates/langchain/basic"
+  },
+  "architecture": {
+    "main_file": "main.py",
+    "agent_file": "agent.py",
+    "entry_point": "run"
+  }
+}
\ No newline at end of file